A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using NUnit.Framework;
5using UnityEngine;
6using UnityEditor.ShaderGraph;
7
8namespace UnityEditor.Graphing.UnitTests
9{
10 [TestFixture]
11 public class BaseMaterialGraphTests
12 {
13 [OneTimeSetUp]
14 public void RunBeforeAnyTests()
15 {
16 Debug.unityLogger.logHandler = new ConsoleLogHandler();
17 }
18
19 [Test]
20 public void TestCanCreateBaseMaterialGraph()
21 {
22 var graph = new GraphData();
23
24 Assert.AreEqual(0, graph.edges.Count());
25 Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
26 }
27
28 [Test]
29 public void TestCanAddNodeToBaseMaterialGraph()
30 {
31 var graph = new GraphData();
32 var node = new TestNode();
33 node.name = "Test Node";
34 graph.AddNode(node);
35
36 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
37 Assert.AreEqual("Test Node", graph.GetNodes<AbstractMaterialNode>().FirstOrDefault().name);
38 Assert.AreEqual(graph, node.owner);
39 }
40
41 [Test]
42 public void TestCanRemoveNodeFromBaseMaterialGraph()
43 {
44 var graph = new GraphData();
45 var node = new TestNode();
46 node.name = "Test Node";
47 graph.AddNode(node);
48 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
49
50 graph.RemoveNode(graph.GetNodes<AbstractMaterialNode>().FirstOrDefault());
51 Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
52 }
53
54 [Test]
55 public void TestCanModifyNodeDrawState()
56 {
57 var node = new TestNode();
58 node.name = "Test Node";
59
60 var drawState = node.drawState;
61 var newPos = new Rect(10, 10, 0, 0);
62 drawState.position = newPos;
63 drawState.expanded = false;
64 node.drawState = drawState;
65
66 Assert.AreEqual(drawState, node.drawState);
67 Assert.AreEqual(newPos, node.drawState.position);
68 Assert.IsFalse(node.drawState.expanded);
69 }
70
71 class SetErrorNode : TestNode
72 {
73 public void SetError()
74 {
75 hasError = true;
76 }
77
78 public void ClearError()
79 {
80 hasError = false;
81 }
82 }
83
84 [Test]
85 public void TestChildClassCanModifyErrorState()
86 {
87 var node = new SetErrorNode();
88 node.SetError();
89 Assert.IsTrue(node.hasError);
90 node.ClearError();
91 Assert.IsFalse(node.hasError);
92 }
93
94 class TestableNode : TestNode
95 {
96 public const int Input0 = 0;
97 public const int Input1 = 1;
98 public const int Input2 = 2;
99
100 public const int Output0 = 3;
101 public const int Output1 = 4;
102 public const int Output2 = 5;
103
104 public TestableNode() : base()
105 {
106 AddSlot(new TestSlot(Input0, "Input", SlotType.Input));
107 AddSlot(new TestSlot(Input1, "Input", SlotType.Input));
108 AddSlot(new TestSlot(Input2, "Input", SlotType.Input));
109
110 AddSlot(new TestSlot(Output0, "Output", SlotType.Output));
111 AddSlot(new TestSlot(Output1, "Output", SlotType.Output));
112 AddSlot(new TestSlot(Output2, "Output", SlotType.Output));
113 }
114 }
115
116 [Test]
117 public void TestRemoveNodeFromBaseMaterialGraphCleansEdges()
118 {
119 var graph = new GraphData();
120 var outputNode = new TestableNode();
121 graph.AddNode(outputNode);
122
123 var inputNode = new TestableNode();
124 graph.AddNode(inputNode);
125
126 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
127 var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
128 Assert.AreEqual(1, graph.edges.Count());
129
130 var edge = graph.edges.FirstOrDefault();
131
132 Assert.AreEqual(createdEdge, edge);
133
134 graph.RemoveNode(outputNode);
135
136 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
137 Assert.AreEqual(0, graph.edges.Count());
138 Assert.AreEqual(inputNode, graph.GetNodes<AbstractMaterialNode>().FirstOrDefault());
139 }
140
141 private class NoDeleteNode : TestNode
142 {
143 public override bool canDeleteNode { get { return false; } }
144 }
145
146 [Test]
147 public void TestCanNotRemoveNoDeleteNodeFromBaseMaterialGraph()
148 {
149 var graph = new GraphData();
150 var node = new NoDeleteNode();
151 node.name = "Test Node";
152 graph.AddNode(node);
153 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
154 Assert.Catch<InvalidOperationException>(() => graph.RemoveNode(node));
155 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
156 }
157
158 private class OnEnableNode : TestNode, IOnAssetEnabled
159 {
160 public bool called = false;
161 public void OnEnable()
162 {
163 called = true;
164 }
165 }
166
167 [Test]
168 public void TestSerializedGraphDelegatesOnEnableCalls()
169 {
170 var graph = new GraphData();
171 var node = new OnEnableNode();
172 node.name = "Test Node";
173 graph.AddNode(node);
174
175 Assert.IsFalse(node.called);
176 graph.OnEnable();
177 Assert.IsTrue(node.called);
178 }
179
180 [Test]
181 public void TestCanFindNodeInBaseMaterialGraph()
182 {
183 var graph = new GraphData();
184 var node = new TestNode();
185 graph.AddNode(node);
186
187 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
188 Assert.IsNotNull(graph.GetNodeFromId(node.objectId));
189 Assert.IsNull(graph.GetNodeFromId("asdfffsd"));
190 }
191
192 [Test]
193 public void TestCanAddSlotToTestNode()
194 {
195 var graph = new GraphData();
196 var node = new TestNode();
197 node.AddSlot(new TestSlot(0, "output", SlotType.Output));
198 node.AddSlot(new TestSlot(1, "input", SlotType.Input));
199 node.name = "Test Node";
200 graph.AddNode(node);
201
202 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
203 var found = graph.GetNodes<AbstractMaterialNode>().FirstOrDefault();
204 Assert.AreEqual(1, found.GetInputSlots<MaterialSlot>().Count());
205 Assert.AreEqual(1, found.GetInputSlots<MaterialSlot>().FirstOrDefault().id);
206 Assert.AreEqual(1, found.GetOutputSlots<MaterialSlot>().Count());
207 Assert.AreEqual(0, found.GetOutputSlots<MaterialSlot>().FirstOrDefault().id);
208 Assert.AreEqual(2, found.GetSlots<MaterialSlot>().Count());
209 }
210
211 [Test]
212 public void TestCanNotAddNullSlotToTestNode()
213 {
214 var node = new TestNode();
215 Assert.Throws<ArgumentException>(() => node.AddSlot(null));
216 }
217
218 [Test]
219 public void TestCanRemoveSlotFromTestNode()
220 {
221 var graph = new GraphData();
222 var node = new TestNode();
223 node.AddSlot(new TestSlot(0, "output", SlotType.Output));
224 node.AddSlot(new TestSlot(1, "input", SlotType.Input));
225 graph.AddNode(node);
226
227 Assert.AreEqual(2, node.GetSlots<MaterialSlot>().Count());
228 Assert.AreEqual(1, node.GetInputSlots<MaterialSlot>().Count());
229 Assert.AreEqual(1, node.GetOutputSlots<MaterialSlot>().Count());
230
231 node.RemoveSlot(1);
232
233 Assert.AreEqual(1, node.GetSlots<MaterialSlot>().Count());
234 Assert.AreEqual(0, node.GetInputSlots<MaterialSlot>().Count());
235 Assert.AreEqual(1, node.GetOutputSlots<MaterialSlot>().Count());
236 }
237
238 [Test]
239 public void TestCanRemoveSlotsWithNonMathingNameFromTestNode()
240 {
241 var graph = new GraphData();
242 var node = new TestableNode();
243 graph.AddNode(node);
244
245 Assert.AreEqual(6, node.GetSlots<MaterialSlot>().Count());
246 Assert.AreEqual(3, node.GetInputSlots<MaterialSlot>().Count());
247 Assert.AreEqual(3, node.GetOutputSlots<MaterialSlot>().Count());
248
249 node.RemoveSlotsNameNotMatching(new[] { TestableNode.Input1 });
250
251 Assert.AreEqual(1, node.GetSlots<MaterialSlot>().Count());
252 Assert.AreEqual(1, node.GetInputSlots<MaterialSlot>().Count());
253 Assert.AreEqual(0, node.GetOutputSlots<MaterialSlot>().Count());
254
255 Assert.IsNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input0));
256 Assert.IsNotNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input1));
257 Assert.IsNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input2));
258 }
259
260 [Test]
261 public void TestCanNotAddDuplicateSlotToTestNode()
262 {
263 var graph = new GraphData();
264 var node = new TestNode();
265 node.AddSlot(new TestSlot(0, "output", SlotType.Output));
266 node.AddSlot(new TestSlot(0, "output", SlotType.Output));
267 node.name = "Test Node";
268 graph.AddNode(node);
269
270 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
271 var found = graph.GetNodes<AbstractMaterialNode>().FirstOrDefault();
272 Assert.AreEqual(0, found.GetInputSlots<MaterialSlot>().Count());
273 Assert.AreEqual(1, found.GetOutputSlots<MaterialSlot>().Count());
274 Assert.AreEqual(1, found.GetSlots<MaterialSlot>().Count());
275 }
276
277 [Test]
278 public void TestCanUpdateDisplaynameByReaddingSlotToTestNode()
279 {
280 var graph = new GraphData();
281 var node = new TestNode();
282 node.AddSlot(new TestSlot(0, "output", SlotType.Output));
283 node.AddSlot(new TestSlot(0, "output_updated", SlotType.Output));
284 node.name = "Test Node";
285 graph.AddNode(node);
286
287 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
288 var found = graph.GetNodes<AbstractMaterialNode>().FirstOrDefault();
289 Assert.AreEqual(0, found.GetInputSlots<MaterialSlot>().Count());
290 Assert.AreEqual(1, found.GetOutputSlots<MaterialSlot>().Count());
291 Assert.AreEqual(1, found.GetSlots<MaterialSlot>().Count());
292
293 var slot = found.GetOutputSlots<MaterialSlot>().FirstOrDefault();
294 Assert.AreEqual("output_updated(4)", slot.displayName);
295 }
296
297 [Test]
298 public void TestCanUpdateSlotDisplayName()
299 {
300 var node = new TestNode();
301 node.AddSlot(new TestSlot(0, "output", SlotType.Output));
302 node.name = "Test Node";
303
304 Assert.AreEqual(0, node.GetInputSlots<MaterialSlot>().Count());
305 Assert.AreEqual(1, node.GetOutputSlots<MaterialSlot>().Count());
306 Assert.AreEqual(1, node.GetSlots<MaterialSlot>().Count());
307
308 var slot = node.GetOutputSlots<MaterialSlot>().FirstOrDefault();
309 Assert.IsNotNull(slot);
310 Assert.AreEqual("output(4)", slot.displayName);
311 slot.displayName = "test";
312 Assert.AreEqual("test(4)", slot.displayName);
313 }
314
315 [Test]
316 public void TestCanFindSlotOnTestNode()
317 {
318 var node = new TestableNode();
319
320 Assert.AreEqual(6, node.GetSlots<MaterialSlot>().Count());
321 Assert.IsNotNull(node.FindInputSlot<MaterialSlot>(TestableNode.Input0));
322 Assert.IsNull(node.FindInputSlot<MaterialSlot>(TestableNode.Output0));
323 Assert.IsNotNull(node.FindOutputSlot<MaterialSlot>(TestableNode.Output0));
324 Assert.IsNull(node.FindOutputSlot<MaterialSlot>(TestableNode.Input0));
325
326 Assert.IsNotNull(node.FindSlot<MaterialSlot>(TestableNode.Input0));
327 Assert.IsNotNull(node.FindSlot<MaterialSlot>(TestableNode.Output0));
328 Assert.IsNull(node.FindSlot<MaterialSlot>(555));
329 }
330
331 [Test]
332 public void TestCanFindSlotReferenceOnTestNode()
333 {
334 var node = new TestableNode();
335
336 Assert.AreEqual(6, node.GetSlots<MaterialSlot>().Count());
337 Assert.IsNotNull(node.GetSlotReference(TestableNode.Input0));
338 Assert.IsNotNull(node.GetSlotReference(TestableNode.Output0));
339 Assert.Throws<ArgumentException>(() => node.GetSlotReference(555));
340 }
341
342 [Test]
343 public void TestCanConnectAndTraverseTwoNodesOnBaseMaterialGraph()
344 {
345 var graph = new GraphData();
346
347 var outputNode = new TestableNode();
348 graph.AddNode(outputNode);
349
350 var inputNode = new TestableNode();
351 graph.AddNode(inputNode);
352
353 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
354
355
356 var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
357 Assert.AreEqual(1, graph.edges.Count());
358
359 var edge = graph.edges.FirstOrDefault();
360
361 Assert.AreEqual(createdEdge, edge);
362
363 var foundOutputNode = edge.outputSlot.node;
364 var foundOutputSlot = foundOutputNode.FindOutputSlot<MaterialSlot>(edge.outputSlot.slotId);
365 Assert.AreEqual(outputNode, foundOutputNode);
366 Assert.IsNotNull(foundOutputSlot);
367
368 var foundInputNode = edge.inputSlot.node;
369 var foundInputSlot = foundInputNode.FindInputSlot<MaterialSlot>(edge.inputSlot.slotId);
370 Assert.AreEqual(inputNode, foundInputNode);
371 Assert.IsNotNull(foundInputSlot);
372 }
373
374 [Test]
375 public void TestCanConnectAndTraverseThreeNodesOnBaseMaterialGraph()
376 {
377 var graph = new GraphData();
378
379 var outputNode = new TestableNode();
380 graph.AddNode(outputNode);
381
382 var middleNode = new TestableNode();
383 graph.AddNode(middleNode);
384
385 var inputNode = new TestableNode();
386 graph.AddNode(inputNode);
387
388 Assert.AreEqual(3, graph.GetNodes<AbstractMaterialNode>().Count());
389
390 graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), middleNode.GetSlotReference(TestableNode.Input0));
391 Assert.AreEqual(1, graph.edges.Count());
392
393 graph.Connect(middleNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
394 Assert.AreEqual(2, graph.edges.Count());
395
396 var edgesOnMiddleNode = NodeUtils.GetAllEdges(middleNode);
397 Assert.AreEqual(2, edgesOnMiddleNode.Count());
398
399 outputNode.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
400 middleNode.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
401 inputNode.SetOverrideActiveState(AbstractMaterialNode.ActiveState.ExplicitActive);
402 var result = new HashSet<AbstractMaterialNode>();
403 NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode);
404 Assert.AreEqual(3, result.Count);
405
406 result.Clear();
407 NodeUtils.DepthFirstCollectNodesFromNode(result, inputNode, NodeUtils.IncludeSelf.Exclude);
408 Assert.AreEqual(2, result.Count);
409
410 result.Clear();
411 NodeUtils.DepthFirstCollectNodesFromNode(result, null);
412 Assert.AreEqual(0, result.Count);
413 }
414
415 [Test]
416 public void TestExceptionIfBadNodeConfigurationWorks()
417 {
418 var node = new TestableNode();
419 Assert.DoesNotThrow(
420 () =>
421 NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
422 node,
423 new[] { TestableNode.Input0, TestableNode.Input1, TestableNode.Input2 },
424 new[] { TestableNode.Output0, TestableNode.Output1, TestableNode.Output2, })
425 );
426
427
428 Assert.Throws<SlotConfigurationException>(
429 () =>
430 NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
431 node,
432 new[] { 666, TestableNode.Input1, TestableNode.Input2 },
433 new[] { TestableNode.Output0, TestableNode.Output1, TestableNode.Output2, })
434 );
435
436 Assert.Throws<SlotConfigurationException>(
437 () =>
438 NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
439 node,
440 new[] { TestableNode.Input0, TestableNode.Input1, TestableNode.Input2 },
441 new[] { 666, TestableNode.Output1, TestableNode.Output2, })
442 );
443
444 Assert.DoesNotThrow(
445 () =>
446 NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
447 node,
448 new[] { TestableNode.Input0 },
449 new[] { TestableNode.Output0 })
450 );
451 }
452
453 [Test]
454 public void TestConectionToSameInputReplacesOldInput()
455 {
456 var graph = new GraphData();
457
458 var outputNode = new TestableNode();
459 graph.AddNode(outputNode);
460
461 var inputNode = new TestableNode();
462 graph.AddNode(inputNode);
463
464 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
465
466 var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
467 Assert.AreEqual(1, graph.edges.Count());
468 var edge = graph.edges.FirstOrDefault();
469 Assert.AreEqual(createdEdge, edge);
470
471 var createdEdge2 = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
472 Assert.AreEqual(1, graph.edges.Count());
473 var edge2 = graph.edges.FirstOrDefault();
474 Assert.AreEqual(createdEdge2, edge2);
475 }
476
477 [Test]
478 public void TestRemovingSlotRemovesConnectedEdges()
479 {
480 var graph = new GraphData();
481
482 var outputNode = new TestableNode();
483 graph.AddNode(outputNode);
484
485 var inputNode = new TestableNode();
486 graph.AddNode(inputNode);
487
488 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
489
490 graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
491 Assert.AreEqual(1, graph.edges.Count());
492
493 outputNode.RemoveSlot(TestableNode.Output0);
494 Assert.AreEqual(0, graph.edges.Count());
495 }
496
497 [Test]
498 public void TestCanNotConnectToNullSlot()
499 {
500 var graph = new GraphData();
501
502 var outputNode = new TestableNode();
503 graph.AddNode(outputNode);
504
505 var inputNode = new TestNode();
506 graph.AddNode(inputNode);
507
508 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
509
510 var createdEdge2 = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), new SlotReference(null, 666));
511 Assert.AreEqual(0, graph.edges.Count());
512 Assert.IsNull(createdEdge2);
513 }
514
515 [Test]
516 public void TestCanNotConnectTwoOuputSlotsOnBaseMaterialGraph()
517 {
518 var graph = new GraphData();
519
520 var outputNode = new TestableNode();
521 graph.AddNode(outputNode);
522
523 var outputNode2 = new TestableNode();
524 graph.AddNode(outputNode2);
525
526 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
527
528 var createdEdge = graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), outputNode2.GetSlotReference(TestableNode.Output0));
529 Assert.IsNull(createdEdge);
530 Assert.AreEqual(0, graph.edges.Count());
531 }
532
533 [Test]
534 public void TestCanNotConnectTwoInputSlotsOnBaseMaterialGraph()
535 {
536 var graph = new GraphData();
537
538 var inputNode = new TestableNode();
539 graph.AddNode(inputNode);
540
541 var inputNode2 = new TestableNode();
542 graph.AddNode(inputNode2);
543
544 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
545
546 var createdEdge = graph.Connect(inputNode.GetSlotReference(TestableNode.Input0), inputNode2.GetSlotReference(TestableNode.Input0));
547 Assert.IsNull(createdEdge);
548 Assert.AreEqual(0, graph.edges.Count());
549 }
550
551 [Test]
552 public void TestRemovingNodeRemovesConectedEdgesOnBaseMaterialGraph()
553 {
554 var graph = new GraphData();
555 var outputNode = new TestableNode();
556 graph.AddNode(outputNode);
557
558 var inputNode = new TestableNode();
559 graph.AddNode(inputNode);
560
561 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
562 graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
563 Assert.AreEqual(1, graph.edges.Count());
564
565 graph.RemoveNode(graph.GetNodes<AbstractMaterialNode>().FirstOrDefault());
566 Assert.AreEqual(1, graph.GetNodes<AbstractMaterialNode>().Count());
567 Assert.AreEqual(0, graph.edges.Count());
568 }
569
570 [Test]
571 public void TestRemovingEdgeOnBaseMaterialGraph()
572 {
573 var graph = new GraphData();
574 var outputNode = new TestableNode();
575 graph.AddNode(outputNode);
576
577 var inputNode = new TestableNode();
578 graph.AddNode(inputNode);
579
580 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
581 graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
582 Assert.AreEqual(1, graph.edges.Count());
583
584 graph.RemoveEdge(graph.edges.FirstOrDefault());
585 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
586 Assert.AreEqual(0, graph.edges.Count());
587 }
588
589 [Test]
590 public void TestRemovingElementsFromBaseMaterialGraph()
591 {
592 var graph = new GraphData();
593 var outputNode = new TestableNode();
594 graph.AddNode(outputNode);
595
596 var inputNode = new TestableNode();
597 graph.AddNode(inputNode);
598
599 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
600 graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
601 Assert.AreEqual(1, graph.edges.Count());
602
603 graph.RemoveElements(graph.GetNodes<AbstractMaterialNode>().ToArray(), graph.edges.ToArray(), new GroupData[] { }, new StickyNoteData[] { });
604 Assert.AreEqual(0, graph.GetNodes<AbstractMaterialNode>().Count());
605 Assert.AreEqual(0, graph.edges.Count());
606 }
607
608 [Test]
609 public void TestCanGetEdgesOnBaseMaterialGraphFromSlotReference()
610 {
611 var graph = new GraphData();
612 var outputNode = new TestableNode();
613 graph.AddNode(outputNode);
614
615 var inputNode = new TestableNode();
616 graph.AddNode(inputNode);
617
618 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
619 graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
620 Assert.AreEqual(1, graph.edges.Count());
621
622 Assert.AreEqual(1, graph.GetEdges(inputNode.GetSlotReference(TestableNode.Input0)).Count());
623 Assert.AreEqual(1, graph.GetEdges(outputNode.GetSlotReference(TestableNode.Output0)).Count());
624 Assert.Throws<ArgumentException>(() => outputNode.GetSlotReference(666));
625 }
626
627 [Test]
628 public void TestGetInputsWithNoConnection()
629 {
630 var graph = new GraphData();
631
632 var outputNode = new TestableNode();
633 graph.AddNode(outputNode);
634
635 var inputNode = new TestableNode();
636 graph.AddNode(inputNode);
637
638 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
639 graph.Connect(outputNode.GetSlotReference(TestableNode.Output0), inputNode.GetSlotReference(TestableNode.Input0));
640 Assert.AreEqual(1, graph.edges.Count());
641
642 var slots = inputNode.GetInputsWithNoConnection();
643 Assert.AreEqual(2, slots.Count());
644 CollectionAssert.AreEqual(new[] { TestableNode.Input1, TestableNode.Input2 }, slots.Select(x => x.id));
645 }
646
647 [Test]
648 public void TestCyclicConnectionsAreNotAllowedOnGraph()
649 {
650 var graph = new GraphData();
651
652 var nodeA = new TestableNode();
653
654 graph.AddNode(nodeA);
655
656 var nodeB = new TestableNode();
657 graph.AddNode(nodeB);
658
659 Assert.AreEqual(2, graph.GetNodes<AbstractMaterialNode>().Count());
660 graph.Connect(nodeA.GetSlotReference(TestableNode.Output0), nodeB.GetSlotReference(TestableNode.Input0));
661 Assert.AreEqual(1, graph.edges.Count());
662
663 var edge = graph.Connect(nodeB.GetSlotReference(TestableNode.Output0), nodeA.GetSlotReference(TestableNode.Input0));
664 Assert.IsNull(edge);
665 Assert.AreEqual(1, graph.edges.Count());
666 }
667 }
668}