com.wallstop-studios.dxmessaging 2.0.0-rc06 → 2.0.0-rc07
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/Runtime/Core/InstanceId.cs +41 -14
- package/Runtime/Core/MessageBus/IMessageBus.cs +84 -24
- package/Runtime/Core/MessageBus/MessageBus.cs +892 -205
- package/Runtime/Core/MessageHandler.cs +1469 -331
- package/Runtime/Core/MessageRegistrationHandle.cs +71 -16
- package/Runtime/Core/MessageRegistrationToken.cs +534 -185
- package/Runtime/Unity/MessagingComponent.cs +33 -18
- package/Tests/Runtime/Core/BroadcastTests.cs +283 -51
- package/Tests/Runtime/Core/TargetedTests.cs +279 -53
- package/Tests/Runtime/Core/UntargetedTests.cs +73 -7
- package/package.json +1 -1
|
@@ -1,26 +1,35 @@
|
|
|
1
1
|
namespace DxMessaging.Tests.Runtime.Core
|
|
2
2
|
{
|
|
3
|
-
using DxMessaging.Core;
|
|
4
|
-
using Scripts.Components;
|
|
5
|
-
using Scripts.Messages;
|
|
6
3
|
using System.Collections;
|
|
4
|
+
using System.Linq;
|
|
5
|
+
using DxMessaging.Core;
|
|
7
6
|
using DxMessaging.Core.Extensions;
|
|
7
|
+
using DxMessaging.Core.Messages;
|
|
8
8
|
using NUnit.Framework;
|
|
9
|
+
using Scripts.Components;
|
|
10
|
+
using Scripts.Messages;
|
|
9
11
|
using UnityEngine;
|
|
10
12
|
using UnityEngine.TestTools;
|
|
11
|
-
using DxMessaging.Core.Messages;
|
|
12
13
|
|
|
13
14
|
public sealed class TargetedTests : MessagingTestBase
|
|
14
15
|
{
|
|
15
16
|
[UnityTest]
|
|
16
17
|
public IEnumerator SimpleGameObjectTargetedNormal()
|
|
17
18
|
{
|
|
18
|
-
GameObject test1 = new(
|
|
19
|
+
GameObject test1 = new(
|
|
20
|
+
nameof(SimpleGameObjectTargetedNormal) + "1",
|
|
21
|
+
typeof(EmptyMessageAwareComponent)
|
|
22
|
+
);
|
|
19
23
|
_spawned.Add(test1);
|
|
20
|
-
GameObject test2 = new(
|
|
24
|
+
GameObject test2 = new(
|
|
25
|
+
nameof(SimpleGameObjectTargetedNormal) + "2",
|
|
26
|
+
typeof(EmptyMessageAwareComponent)
|
|
27
|
+
);
|
|
21
28
|
_spawned.Add(test2);
|
|
22
|
-
EmptyMessageAwareComponent component1 =
|
|
23
|
-
|
|
29
|
+
EmptyMessageAwareComponent component1 =
|
|
30
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
31
|
+
EmptyMessageAwareComponent component2 =
|
|
32
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
24
33
|
|
|
25
34
|
int test1TargetedCount = 0;
|
|
26
35
|
int test2TargetedCount = 0;
|
|
@@ -28,8 +37,14 @@
|
|
|
28
37
|
MessageRegistrationToken token1 = GetToken(component1);
|
|
29
38
|
MessageRegistrationToken token2 = GetToken(component2);
|
|
30
39
|
|
|
31
|
-
_ = token1.RegisterGameObjectTargeted<SimpleTargetedMessage>(
|
|
32
|
-
|
|
40
|
+
_ = token1.RegisterGameObjectTargeted<SimpleTargetedMessage>(
|
|
41
|
+
test1,
|
|
42
|
+
_ => ++test1TargetedCount
|
|
43
|
+
);
|
|
44
|
+
_ = token2.RegisterGameObjectTargeted<SimpleTargetedMessage>(
|
|
45
|
+
test2,
|
|
46
|
+
_ => ++test2TargetedCount
|
|
47
|
+
);
|
|
33
48
|
|
|
34
49
|
SimpleTargetedMessage message = new();
|
|
35
50
|
message.EmitGameObjectTargeted(test1);
|
|
@@ -68,12 +83,20 @@
|
|
|
68
83
|
[UnityTest]
|
|
69
84
|
public IEnumerator SimpleGameObjectTargetedNoCopy()
|
|
70
85
|
{
|
|
71
|
-
GameObject test1 = new(
|
|
86
|
+
GameObject test1 = new(
|
|
87
|
+
nameof(SimpleGameObjectTargetedNoCopy) + "1",
|
|
88
|
+
typeof(EmptyMessageAwareComponent)
|
|
89
|
+
);
|
|
72
90
|
_spawned.Add(test1);
|
|
73
|
-
GameObject test2 = new(
|
|
91
|
+
GameObject test2 = new(
|
|
92
|
+
nameof(SimpleGameObjectTargetedNoCopy) + "2",
|
|
93
|
+
typeof(EmptyMessageAwareComponent)
|
|
94
|
+
);
|
|
74
95
|
_spawned.Add(test2);
|
|
75
|
-
EmptyMessageAwareComponent component1 =
|
|
76
|
-
|
|
96
|
+
EmptyMessageAwareComponent component1 =
|
|
97
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
98
|
+
EmptyMessageAwareComponent component2 =
|
|
99
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
77
100
|
|
|
78
101
|
int test1TargetedCount = 0;
|
|
79
102
|
void Test1Receive(ref SimpleTargetedMessage message)
|
|
@@ -129,12 +152,20 @@
|
|
|
129
152
|
[UnityTest]
|
|
130
153
|
public IEnumerator SimpleGameObjectTargetedDualMode()
|
|
131
154
|
{
|
|
132
|
-
GameObject test1 = new(
|
|
155
|
+
GameObject test1 = new(
|
|
156
|
+
nameof(SimpleGameObjectTargetedDualMode) + "1",
|
|
157
|
+
typeof(EmptyMessageAwareComponent)
|
|
158
|
+
);
|
|
133
159
|
_spawned.Add(test1);
|
|
134
|
-
GameObject test2 = new(
|
|
160
|
+
GameObject test2 = new(
|
|
161
|
+
nameof(SimpleGameObjectTargetedDualMode) + "2",
|
|
162
|
+
typeof(EmptyMessageAwareComponent)
|
|
163
|
+
);
|
|
135
164
|
_spawned.Add(test2);
|
|
136
|
-
EmptyMessageAwareComponent component1 =
|
|
137
|
-
|
|
165
|
+
EmptyMessageAwareComponent component1 =
|
|
166
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
167
|
+
EmptyMessageAwareComponent component2 =
|
|
168
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
138
169
|
|
|
139
170
|
int test1ReceiveCount = 0;
|
|
140
171
|
void Test1Receive(ref SimpleTargetedMessage message)
|
|
@@ -152,7 +183,10 @@
|
|
|
152
183
|
MessageRegistrationToken token2 = GetToken(component2);
|
|
153
184
|
|
|
154
185
|
_ = token1.RegisterGameObjectTargeted<SimpleTargetedMessage>(test1, Test1Receive);
|
|
155
|
-
_ = token1.RegisterGameObjectTargeted<SimpleTargetedMessage>(
|
|
186
|
+
_ = token1.RegisterGameObjectTargeted<SimpleTargetedMessage>(
|
|
187
|
+
test1,
|
|
188
|
+
_ => ++test1ReceiveCount
|
|
189
|
+
);
|
|
156
190
|
_ = token2.RegisterGameObjectTargeted<SimpleTargetedMessage>(test2, Test2Receive);
|
|
157
191
|
|
|
158
192
|
SimpleTargetedMessage message = new();
|
|
@@ -191,12 +225,20 @@
|
|
|
191
225
|
[UnityTest]
|
|
192
226
|
public IEnumerator SimpleComponentTargetedNormal()
|
|
193
227
|
{
|
|
194
|
-
GameObject test1 = new(
|
|
228
|
+
GameObject test1 = new(
|
|
229
|
+
nameof(SimpleComponentTargetedNormal) + "1",
|
|
230
|
+
typeof(EmptyMessageAwareComponent)
|
|
231
|
+
);
|
|
195
232
|
_spawned.Add(test1);
|
|
196
|
-
GameObject test2 = new(
|
|
233
|
+
GameObject test2 = new(
|
|
234
|
+
nameof(SimpleComponentTargetedNormal) + "3",
|
|
235
|
+
typeof(EmptyMessageAwareComponent)
|
|
236
|
+
);
|
|
197
237
|
_spawned.Add(test2);
|
|
198
|
-
EmptyMessageAwareComponent component1 =
|
|
199
|
-
|
|
238
|
+
EmptyMessageAwareComponent component1 =
|
|
239
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
240
|
+
EmptyMessageAwareComponent component2 =
|
|
241
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
200
242
|
|
|
201
243
|
int test1ReceiveCount = 0;
|
|
202
244
|
int test2ReceiveCount = 0;
|
|
@@ -204,8 +246,14 @@
|
|
|
204
246
|
MessageRegistrationToken token1 = GetToken(component1);
|
|
205
247
|
MessageRegistrationToken token2 = GetToken(component2);
|
|
206
248
|
|
|
207
|
-
_ = token1.RegisterComponentTargeted<SimpleTargetedMessage>(
|
|
208
|
-
|
|
249
|
+
_ = token1.RegisterComponentTargeted<SimpleTargetedMessage>(
|
|
250
|
+
component1,
|
|
251
|
+
_ => ++test1ReceiveCount
|
|
252
|
+
);
|
|
253
|
+
_ = token2.RegisterComponentTargeted<SimpleTargetedMessage>(
|
|
254
|
+
component2,
|
|
255
|
+
_ => ++test2ReceiveCount
|
|
256
|
+
);
|
|
209
257
|
|
|
210
258
|
SimpleTargetedMessage message = new();
|
|
211
259
|
message.EmitComponentTargeted(component1);
|
|
@@ -222,7 +270,8 @@
|
|
|
222
270
|
Assert.AreEqual(1, test1ReceiveCount);
|
|
223
271
|
Assert.AreEqual(1, test2ReceiveCount);
|
|
224
272
|
|
|
225
|
-
EmptyMessageAwareComponent component3 =
|
|
273
|
+
EmptyMessageAwareComponent component3 =
|
|
274
|
+
test3.AddComponent<EmptyMessageAwareComponent>();
|
|
226
275
|
message.EmitComponentTargeted(component3);
|
|
227
276
|
Assert.AreEqual(1, test1ReceiveCount);
|
|
228
277
|
Assert.AreEqual(1, test2ReceiveCount);
|
|
@@ -244,12 +293,20 @@
|
|
|
244
293
|
[UnityTest]
|
|
245
294
|
public IEnumerator SimpleComponentTargetedNoCopy()
|
|
246
295
|
{
|
|
247
|
-
GameObject test1 = new(
|
|
296
|
+
GameObject test1 = new(
|
|
297
|
+
nameof(SimpleComponentTargetedNoCopy) + "1",
|
|
298
|
+
typeof(EmptyMessageAwareComponent)
|
|
299
|
+
);
|
|
248
300
|
_spawned.Add(test1);
|
|
249
|
-
GameObject test2 = new(
|
|
301
|
+
GameObject test2 = new(
|
|
302
|
+
nameof(SimpleComponentTargetedNoCopy) + "2",
|
|
303
|
+
typeof(EmptyMessageAwareComponent)
|
|
304
|
+
);
|
|
250
305
|
_spawned.Add(test2);
|
|
251
|
-
EmptyMessageAwareComponent component1 =
|
|
252
|
-
|
|
306
|
+
EmptyMessageAwareComponent component1 =
|
|
307
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
308
|
+
EmptyMessageAwareComponent component2 =
|
|
309
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
253
310
|
|
|
254
311
|
int test1ReceiveCount = 0;
|
|
255
312
|
void Test1Receive(ref SimpleTargetedMessage message)
|
|
@@ -284,7 +341,8 @@
|
|
|
284
341
|
Assert.AreEqual(1, test1ReceiveCount);
|
|
285
342
|
Assert.AreEqual(1, test2ReceiveCount);
|
|
286
343
|
|
|
287
|
-
EmptyMessageAwareComponent component3 =
|
|
344
|
+
EmptyMessageAwareComponent component3 =
|
|
345
|
+
test3.AddComponent<EmptyMessageAwareComponent>();
|
|
288
346
|
message.EmitComponentTargeted(component3);
|
|
289
347
|
Assert.AreEqual(1, test1ReceiveCount);
|
|
290
348
|
Assert.AreEqual(1, test2ReceiveCount);
|
|
@@ -306,12 +364,20 @@
|
|
|
306
364
|
[UnityTest]
|
|
307
365
|
public IEnumerator SimpleComponentTargetedDualMode()
|
|
308
366
|
{
|
|
309
|
-
GameObject test1 = new(
|
|
367
|
+
GameObject test1 = new(
|
|
368
|
+
nameof(SimpleComponentTargetedDualMode) + "1",
|
|
369
|
+
typeof(EmptyMessageAwareComponent)
|
|
370
|
+
);
|
|
310
371
|
_spawned.Add(test1);
|
|
311
|
-
GameObject test2 = new(
|
|
372
|
+
GameObject test2 = new(
|
|
373
|
+
nameof(SimpleComponentTargetedDualMode) + "2",
|
|
374
|
+
typeof(EmptyMessageAwareComponent)
|
|
375
|
+
);
|
|
312
376
|
_spawned.Add(test2);
|
|
313
|
-
EmptyMessageAwareComponent component1 =
|
|
314
|
-
|
|
377
|
+
EmptyMessageAwareComponent component1 =
|
|
378
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
379
|
+
EmptyMessageAwareComponent component2 =
|
|
380
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
315
381
|
|
|
316
382
|
int test1ReceiveCount = 0;
|
|
317
383
|
void Test1Receive(ref SimpleTargetedMessage message)
|
|
@@ -329,7 +395,10 @@
|
|
|
329
395
|
MessageRegistrationToken token2 = GetToken(component2);
|
|
330
396
|
|
|
331
397
|
_ = token1.RegisterComponentTargeted<SimpleTargetedMessage>(component1, Test1Receive);
|
|
332
|
-
_ = token1.RegisterComponentTargeted<SimpleTargetedMessage>(
|
|
398
|
+
_ = token1.RegisterComponentTargeted<SimpleTargetedMessage>(
|
|
399
|
+
component1,
|
|
400
|
+
_ => ++test1ReceiveCount
|
|
401
|
+
);
|
|
333
402
|
_ = token2.RegisterComponentTargeted<SimpleTargetedMessage>(component2, Test2Receive);
|
|
334
403
|
|
|
335
404
|
SimpleTargetedMessage message = new();
|
|
@@ -347,7 +416,8 @@
|
|
|
347
416
|
Assert.AreEqual(2, test1ReceiveCount);
|
|
348
417
|
Assert.AreEqual(1, test2ReceiveCount);
|
|
349
418
|
|
|
350
|
-
EmptyMessageAwareComponent component3 =
|
|
419
|
+
EmptyMessageAwareComponent component3 =
|
|
420
|
+
test3.AddComponent<EmptyMessageAwareComponent>();
|
|
351
421
|
message.EmitComponentTargeted(component3);
|
|
352
422
|
Assert.AreEqual(2, test1ReceiveCount);
|
|
353
423
|
Assert.AreEqual(1, test2ReceiveCount);
|
|
@@ -369,12 +439,20 @@
|
|
|
369
439
|
[UnityTest]
|
|
370
440
|
public IEnumerator SimpleTargetedWithoutTargetingNormal()
|
|
371
441
|
{
|
|
372
|
-
GameObject test1 = new(
|
|
442
|
+
GameObject test1 = new(
|
|
443
|
+
nameof(SimpleTargetedWithoutTargetingNormal) + "1",
|
|
444
|
+
typeof(EmptyMessageAwareComponent)
|
|
445
|
+
);
|
|
373
446
|
_spawned.Add(test1);
|
|
374
|
-
GameObject test2 = new(
|
|
447
|
+
GameObject test2 = new(
|
|
448
|
+
nameof(SimpleTargetedWithoutTargetingNormal) + "2",
|
|
449
|
+
typeof(EmptyMessageAwareComponent)
|
|
450
|
+
);
|
|
375
451
|
_spawned.Add(test2);
|
|
376
|
-
EmptyMessageAwareComponent component1 =
|
|
377
|
-
|
|
452
|
+
EmptyMessageAwareComponent component1 =
|
|
453
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
454
|
+
EmptyMessageAwareComponent component2 =
|
|
455
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
378
456
|
|
|
379
457
|
int test1ReceiveCount = 0;
|
|
380
458
|
void Test1Receive(InstanceId id, SimpleTargetedMessage message)
|
|
@@ -409,7 +487,8 @@
|
|
|
409
487
|
Assert.AreEqual(3, test1ReceiveCount);
|
|
410
488
|
Assert.AreEqual(3, test2ReceiveCount);
|
|
411
489
|
|
|
412
|
-
EmptyMessageAwareComponent component3 =
|
|
490
|
+
EmptyMessageAwareComponent component3 =
|
|
491
|
+
test3.AddComponent<EmptyMessageAwareComponent>();
|
|
413
492
|
message.EmitComponentTargeted(component3);
|
|
414
493
|
Assert.AreEqual(4, test1ReceiveCount);
|
|
415
494
|
Assert.AreEqual(4, test2ReceiveCount);
|
|
@@ -431,12 +510,20 @@
|
|
|
431
510
|
[UnityTest]
|
|
432
511
|
public IEnumerator SimpleTargetedWithoutTargetingNoCopy()
|
|
433
512
|
{
|
|
434
|
-
GameObject test1 = new(
|
|
513
|
+
GameObject test1 = new(
|
|
514
|
+
nameof(SimpleTargetedWithoutTargetingNoCopy) + "1",
|
|
515
|
+
typeof(EmptyMessageAwareComponent)
|
|
516
|
+
);
|
|
435
517
|
_spawned.Add(test1);
|
|
436
|
-
GameObject test2 = new(
|
|
518
|
+
GameObject test2 = new(
|
|
519
|
+
nameof(SimpleTargetedWithoutTargetingNoCopy) + "2",
|
|
520
|
+
typeof(EmptyMessageAwareComponent)
|
|
521
|
+
);
|
|
437
522
|
_spawned.Add(test2);
|
|
438
|
-
EmptyMessageAwareComponent component1 =
|
|
439
|
-
|
|
523
|
+
EmptyMessageAwareComponent component1 =
|
|
524
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
525
|
+
EmptyMessageAwareComponent component2 =
|
|
526
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
440
527
|
|
|
441
528
|
int test1ReceiveCount = 0;
|
|
442
529
|
void Test1Receive(ref InstanceId id, ref SimpleTargetedMessage message)
|
|
@@ -471,7 +558,8 @@
|
|
|
471
558
|
Assert.AreEqual(3, test1ReceiveCount);
|
|
472
559
|
Assert.AreEqual(3, test2ReceiveCount);
|
|
473
560
|
|
|
474
|
-
EmptyMessageAwareComponent component3 =
|
|
561
|
+
EmptyMessageAwareComponent component3 =
|
|
562
|
+
test3.AddComponent<EmptyMessageAwareComponent>();
|
|
475
563
|
message.EmitComponentTargeted(component3);
|
|
476
564
|
Assert.AreEqual(4, test1ReceiveCount);
|
|
477
565
|
Assert.AreEqual(4, test2ReceiveCount);
|
|
@@ -493,12 +581,20 @@
|
|
|
493
581
|
[UnityTest]
|
|
494
582
|
public IEnumerator SimpleTargetedWithoutTargetingDualMode()
|
|
495
583
|
{
|
|
496
|
-
GameObject test1 = new(
|
|
584
|
+
GameObject test1 = new(
|
|
585
|
+
nameof(SimpleTargetedWithoutTargetingDualMode) + "1",
|
|
586
|
+
typeof(EmptyMessageAwareComponent)
|
|
587
|
+
);
|
|
497
588
|
_spawned.Add(test1);
|
|
498
|
-
GameObject test2 = new(
|
|
589
|
+
GameObject test2 = new(
|
|
590
|
+
nameof(SimpleTargetedWithoutTargetingDualMode) + "2",
|
|
591
|
+
typeof(EmptyMessageAwareComponent)
|
|
592
|
+
);
|
|
499
593
|
_spawned.Add(test2);
|
|
500
|
-
EmptyMessageAwareComponent component1 =
|
|
501
|
-
|
|
594
|
+
EmptyMessageAwareComponent component1 =
|
|
595
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
596
|
+
EmptyMessageAwareComponent component2 =
|
|
597
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
502
598
|
|
|
503
599
|
int test1ReceiveCount = 0;
|
|
504
600
|
void Test1Receive(ref InstanceId id, ref SimpleTargetedMessage message)
|
|
@@ -533,7 +629,8 @@
|
|
|
533
629
|
Assert.AreEqual(3, test1ReceiveCount);
|
|
534
630
|
Assert.AreEqual(3, test2ReceiveCount);
|
|
535
631
|
|
|
536
|
-
EmptyMessageAwareComponent component3 =
|
|
632
|
+
EmptyMessageAwareComponent component3 =
|
|
633
|
+
test3.AddComponent<EmptyMessageAwareComponent>();
|
|
537
634
|
message.EmitComponentTargeted(component3);
|
|
538
635
|
Assert.AreEqual(4, test1ReceiveCount);
|
|
539
636
|
Assert.AreEqual(4, test2ReceiveCount);
|
|
@@ -555,7 +652,10 @@
|
|
|
555
652
|
[UnityTest]
|
|
556
653
|
public IEnumerator TargetedUntyped()
|
|
557
654
|
{
|
|
558
|
-
GameObject test = new(
|
|
655
|
+
GameObject test = new(
|
|
656
|
+
nameof(TargetedUntyped) + "1",
|
|
657
|
+
typeof(EmptyMessageAwareComponent)
|
|
658
|
+
);
|
|
559
659
|
_spawned.Add(test);
|
|
560
660
|
|
|
561
661
|
int gameObjectCount = 0;
|
|
@@ -592,5 +692,131 @@
|
|
|
592
692
|
|
|
593
693
|
yield break;
|
|
594
694
|
}
|
|
695
|
+
|
|
696
|
+
[UnityTest]
|
|
697
|
+
public IEnumerator PriorityGameObject()
|
|
698
|
+
{
|
|
699
|
+
GameObject test = new(
|
|
700
|
+
nameof(PriorityGameObject) + "1",
|
|
701
|
+
typeof(EmptyMessageAwareComponent)
|
|
702
|
+
);
|
|
703
|
+
_spawned.Add(test);
|
|
704
|
+
|
|
705
|
+
int[] received = new int[100];
|
|
706
|
+
EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
|
|
707
|
+
MessageRegistrationToken token = GetToken(component);
|
|
708
|
+
for (int i = 0; i < received.Length; ++i)
|
|
709
|
+
{
|
|
710
|
+
int priority = i;
|
|
711
|
+
token.RegisterGameObjectTargeted(
|
|
712
|
+
test,
|
|
713
|
+
(ref SimpleTargetedMessage _) =>
|
|
714
|
+
{
|
|
715
|
+
int previous = received[priority]++;
|
|
716
|
+
if (0 < priority)
|
|
717
|
+
{
|
|
718
|
+
Assert.AreEqual(previous + 1, received[priority - 1]);
|
|
719
|
+
}
|
|
720
|
+
},
|
|
721
|
+
priority: priority
|
|
722
|
+
);
|
|
723
|
+
token.RegisterGameObjectTargetedPostProcessor(
|
|
724
|
+
test,
|
|
725
|
+
(ref SimpleTargetedMessage _) =>
|
|
726
|
+
{
|
|
727
|
+
int previous = received[priority]++;
|
|
728
|
+
Assert.AreEqual(1, previous % 2);
|
|
729
|
+
if (0 < priority)
|
|
730
|
+
{
|
|
731
|
+
Assert.AreEqual(previous + 1, received[priority - 1]);
|
|
732
|
+
}
|
|
733
|
+
},
|
|
734
|
+
priority: priority
|
|
735
|
+
);
|
|
736
|
+
}
|
|
737
|
+
|
|
738
|
+
SimpleTargetedMessage message = new();
|
|
739
|
+
const int numRuns = 100;
|
|
740
|
+
for (int i = 0; i < numRuns; ++i)
|
|
741
|
+
{
|
|
742
|
+
// Should do something
|
|
743
|
+
message.EmitGameObjectTargeted(test);
|
|
744
|
+
// Should do nothing
|
|
745
|
+
message.EmitComponentTargeted(component);
|
|
746
|
+
}
|
|
747
|
+
|
|
748
|
+
Assert.AreEqual(
|
|
749
|
+
1,
|
|
750
|
+
received.Distinct().Count(),
|
|
751
|
+
"Expected received to be uniform, found: [{0}].",
|
|
752
|
+
string.Join(",", received.Distinct().OrderBy(x => x))
|
|
753
|
+
);
|
|
754
|
+
|
|
755
|
+
Assert.AreEqual(numRuns * 2, received.Distinct().Single());
|
|
756
|
+
yield break;
|
|
757
|
+
}
|
|
758
|
+
|
|
759
|
+
[UnityTest]
|
|
760
|
+
public IEnumerator PriorityComponent()
|
|
761
|
+
{
|
|
762
|
+
GameObject test = new(
|
|
763
|
+
nameof(PriorityComponent) + "1",
|
|
764
|
+
typeof(EmptyMessageAwareComponent)
|
|
765
|
+
);
|
|
766
|
+
_spawned.Add(test);
|
|
767
|
+
|
|
768
|
+
int[] received = new int[100];
|
|
769
|
+
EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
|
|
770
|
+
MessageRegistrationToken token = GetToken(component);
|
|
771
|
+
for (int i = 0; i < received.Length; ++i)
|
|
772
|
+
{
|
|
773
|
+
int priority = i;
|
|
774
|
+
token.RegisterComponentTargeted(
|
|
775
|
+
component,
|
|
776
|
+
(ref SimpleTargetedMessage _) =>
|
|
777
|
+
{
|
|
778
|
+
int previous = received[priority]++;
|
|
779
|
+
if (0 < priority)
|
|
780
|
+
{
|
|
781
|
+
Assert.AreEqual(previous + 1, received[priority - 1]);
|
|
782
|
+
}
|
|
783
|
+
},
|
|
784
|
+
priority: priority
|
|
785
|
+
);
|
|
786
|
+
token.RegisterComponentTargetedPostProcessor(
|
|
787
|
+
component,
|
|
788
|
+
(ref SimpleTargetedMessage _) =>
|
|
789
|
+
{
|
|
790
|
+
int previous = received[priority]++;
|
|
791
|
+
Assert.AreEqual(1, previous % 2);
|
|
792
|
+
if (0 < priority)
|
|
793
|
+
{
|
|
794
|
+
Assert.AreEqual(previous + 1, received[priority - 1]);
|
|
795
|
+
}
|
|
796
|
+
},
|
|
797
|
+
priority: priority
|
|
798
|
+
);
|
|
799
|
+
}
|
|
800
|
+
|
|
801
|
+
SimpleTargetedMessage message = new();
|
|
802
|
+
const int numRuns = 100;
|
|
803
|
+
for (int i = 0; i < numRuns; ++i)
|
|
804
|
+
{
|
|
805
|
+
// Should do something
|
|
806
|
+
message.EmitComponentTargeted(component);
|
|
807
|
+
// Should do nothing
|
|
808
|
+
message.EmitGameObjectTargeted(test);
|
|
809
|
+
}
|
|
810
|
+
|
|
811
|
+
Assert.AreEqual(
|
|
812
|
+
1,
|
|
813
|
+
received.Distinct().Count(),
|
|
814
|
+
"Expected received to be uniform, found: [{0}].",
|
|
815
|
+
string.Join(",", received.Distinct().OrderBy(x => x))
|
|
816
|
+
);
|
|
817
|
+
|
|
818
|
+
Assert.AreEqual(numRuns * 2, received.Distinct().Single());
|
|
819
|
+
yield break;
|
|
820
|
+
}
|
|
595
821
|
}
|
|
596
822
|
}
|
|
@@ -1,6 +1,7 @@
|
|
|
1
1
|
namespace DxMessaging.Tests.Runtime.Core
|
|
2
2
|
{
|
|
3
3
|
using System.Collections;
|
|
4
|
+
using System.Linq;
|
|
4
5
|
using DxMessaging.Core;
|
|
5
6
|
using DxMessaging.Core.Extensions;
|
|
6
7
|
using DxMessaging.Core.Messages;
|
|
@@ -20,8 +21,10 @@
|
|
|
20
21
|
GameObject test2 = new(nameof(SimpleNormal) + "2", typeof(EmptyMessageAwareComponent));
|
|
21
22
|
_spawned.Add(test2);
|
|
22
23
|
|
|
23
|
-
EmptyMessageAwareComponent component1 =
|
|
24
|
-
|
|
24
|
+
EmptyMessageAwareComponent component1 =
|
|
25
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
26
|
+
EmptyMessageAwareComponent component2 =
|
|
27
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
25
28
|
|
|
26
29
|
int count1 = 0;
|
|
27
30
|
MessageRegistrationToken token1 = GetToken(component1);
|
|
@@ -48,8 +51,10 @@
|
|
|
48
51
|
GameObject test2 = new(nameof(SimpleNormal) + "2", typeof(EmptyMessageAwareComponent));
|
|
49
52
|
_spawned.Add(test2);
|
|
50
53
|
|
|
51
|
-
EmptyMessageAwareComponent component1 =
|
|
52
|
-
|
|
54
|
+
EmptyMessageAwareComponent component1 =
|
|
55
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
56
|
+
EmptyMessageAwareComponent component2 =
|
|
57
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
53
58
|
|
|
54
59
|
int count1 = 0;
|
|
55
60
|
void Receive1(ref SimpleUntargetedMessage message)
|
|
@@ -86,8 +91,10 @@
|
|
|
86
91
|
GameObject test2 = new(nameof(SimpleNormal) + "2", typeof(EmptyMessageAwareComponent));
|
|
87
92
|
_spawned.Add(test2);
|
|
88
93
|
|
|
89
|
-
EmptyMessageAwareComponent component1 =
|
|
90
|
-
|
|
94
|
+
EmptyMessageAwareComponent component1 =
|
|
95
|
+
test1.GetComponent<EmptyMessageAwareComponent>();
|
|
96
|
+
EmptyMessageAwareComponent component2 =
|
|
97
|
+
test2.GetComponent<EmptyMessageAwareComponent>();
|
|
91
98
|
|
|
92
99
|
int count1 = 0;
|
|
93
100
|
void Receive1(ref SimpleUntargetedMessage message)
|
|
@@ -120,7 +127,10 @@
|
|
|
120
127
|
[UnityTest]
|
|
121
128
|
public IEnumerator UntargetedUntyped()
|
|
122
129
|
{
|
|
123
|
-
GameObject test = new(
|
|
130
|
+
GameObject test = new(
|
|
131
|
+
nameof(UntargetedUntyped) + "1",
|
|
132
|
+
typeof(EmptyMessageAwareComponent)
|
|
133
|
+
);
|
|
124
134
|
_spawned.Add(test);
|
|
125
135
|
|
|
126
136
|
int count = 0;
|
|
@@ -145,5 +155,61 @@
|
|
|
145
155
|
|
|
146
156
|
yield break;
|
|
147
157
|
}
|
|
158
|
+
|
|
159
|
+
[UnityTest]
|
|
160
|
+
public IEnumerator Priority()
|
|
161
|
+
{
|
|
162
|
+
GameObject test = new(nameof(Priority) + "1", typeof(EmptyMessageAwareComponent));
|
|
163
|
+
_spawned.Add(test);
|
|
164
|
+
|
|
165
|
+
int[] received = new int[100];
|
|
166
|
+
EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
|
|
167
|
+
MessageRegistrationToken token = GetToken(component);
|
|
168
|
+
for (int i = 0; i < received.Length; ++i)
|
|
169
|
+
{
|
|
170
|
+
int priority = i;
|
|
171
|
+
token.RegisterUntargeted(
|
|
172
|
+
(ref SimpleUntargetedMessage _) =>
|
|
173
|
+
{
|
|
174
|
+
int previous = received[priority]++;
|
|
175
|
+
if (0 < priority)
|
|
176
|
+
{
|
|
177
|
+
Assert.AreEqual(previous + 1, received[priority - 1]);
|
|
178
|
+
}
|
|
179
|
+
},
|
|
180
|
+
priority: priority
|
|
181
|
+
);
|
|
182
|
+
token.RegisterUntargetedPostProcessor(
|
|
183
|
+
(ref SimpleUntargetedMessage _) =>
|
|
184
|
+
{
|
|
185
|
+
int previous = received[priority]++;
|
|
186
|
+
Assert.AreEqual(1, previous % 2);
|
|
187
|
+
if (0 < priority)
|
|
188
|
+
{
|
|
189
|
+
Assert.AreEqual(previous + 1, received[priority - 1]);
|
|
190
|
+
}
|
|
191
|
+
},
|
|
192
|
+
priority: priority
|
|
193
|
+
);
|
|
194
|
+
}
|
|
195
|
+
|
|
196
|
+
SimpleUntargetedMessage message = new();
|
|
197
|
+
const int numRuns = 100;
|
|
198
|
+
for (int i = 0; i < numRuns; ++i)
|
|
199
|
+
{
|
|
200
|
+
// Should do something
|
|
201
|
+
message.EmitUntargeted();
|
|
202
|
+
}
|
|
203
|
+
|
|
204
|
+
Assert.AreEqual(
|
|
205
|
+
1,
|
|
206
|
+
received.Distinct().Count(),
|
|
207
|
+
"Expected received to be uniform, found: [{0}].",
|
|
208
|
+
string.Join(",", received.Distinct().OrderBy(x => x))
|
|
209
|
+
);
|
|
210
|
+
|
|
211
|
+
Assert.AreEqual(numRuns * 2, received.Distinct().Single());
|
|
212
|
+
yield break;
|
|
213
|
+
}
|
|
148
214
|
}
|
|
149
215
|
}
|