com.wallstop-studios.dxmessaging 2.0.0-rc11 → 2.0.0-rc13

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.
Files changed (107) hide show
  1. package/.gitattributes +63 -63
  2. package/.github/workflows/npm-publish.yml +66 -0
  3. package/CHANGELOG.md.meta +7 -7
  4. package/Editor/Analyzers/Microsoft.CodeAnalysis.CSharp.dll.meta +33 -33
  5. package/Editor/Analyzers/Microsoft.CodeAnalysis.dll.meta +33 -33
  6. package/Editor/Analyzers/System.Reflection.Metadata.dll.meta +33 -33
  7. package/Editor/Analyzers/WallstopStudios.DxMessaging.SourceGenerators.dll.meta +71 -71
  8. package/Editor/Analyzers.meta +8 -8
  9. package/Editor/SetupCscRsp.cs +162 -146
  10. package/Editor/SetupCscRsp.cs.meta +2 -2
  11. package/Editor/WallstopStudios.DxMessaging.Editor.asmdef +17 -17
  12. package/Editor/WallstopStudios.DxMessaging.Editor.asmdef.meta +7 -7
  13. package/Editor.meta +8 -8
  14. package/LICENSE.md +6 -6
  15. package/LICENSE.md.meta +7 -7
  16. package/README.md +387 -363
  17. package/README.md.meta +7 -7
  18. package/Runtime/Core/Attributes/DxAutoMessageTypeAttribute.cs +7 -9
  19. package/Runtime/Core/Attributes/DxAutoMessageTypeAttribute.cs.meta +2 -2
  20. package/Runtime/Core/Attributes/DxBroadcastMessageAttribute.cs +7 -10
  21. package/Runtime/Core/Attributes/DxBroadcastMessageAttribute.cs.meta +2 -2
  22. package/Runtime/Core/Attributes/DxTargetedMessageAttribute.cs +7 -10
  23. package/Runtime/Core/Attributes/DxTargetedMessageAttribute.cs.meta +2 -2
  24. package/Runtime/Core/Attributes/DxUntargetedMessageAttribute.cs +7 -10
  25. package/Runtime/Core/Attributes/DxUntargetedMessageAttribute.cs.meta +2 -2
  26. package/Runtime/Core/Attributes.meta +2 -2
  27. package/Runtime/Core/Extensions/MessageExtensions.cs +342 -275
  28. package/Runtime/Core/Extensions/MessageExtensions.cs.meta +11 -11
  29. package/Runtime/Core/Extensions.meta +8 -8
  30. package/Runtime/Core/IMessage.cs +12 -12
  31. package/Runtime/Core/IMessage.cs.meta +11 -11
  32. package/Runtime/Core/InstanceId.cs +149 -149
  33. package/Runtime/Core/InstanceId.cs.meta +11 -11
  34. package/Runtime/Core/MessageBus/IMessageBus.cs +309 -309
  35. package/Runtime/Core/MessageBus/IMessageBus.cs.meta +11 -11
  36. package/Runtime/Core/MessageBus/MessageBus.cs +2243 -2084
  37. package/Runtime/Core/MessageBus/MessageBus.cs.meta +11 -11
  38. package/Runtime/Core/MessageBus/MessagingRegistration.cs +105 -100
  39. package/Runtime/Core/MessageBus/MessagingRegistration.cs.meta +11 -11
  40. package/Runtime/Core/MessageBus/RegistrationLog.cs +111 -111
  41. package/Runtime/Core/MessageBus/RegistrationLog.cs.meta +11 -11
  42. package/Runtime/Core/MessageBus.meta +8 -8
  43. package/Runtime/Core/MessageHandler.cs +2778 -2759
  44. package/Runtime/Core/MessageHandler.cs.meta +11 -11
  45. package/Runtime/Core/MessageRegistrationHandle.cs +110 -110
  46. package/Runtime/Core/MessageRegistrationHandle.cs.meta +11 -11
  47. package/Runtime/Core/MessageRegistrationToken.cs +1234 -1234
  48. package/Runtime/Core/MessageRegistrationToken.cs.meta +11 -11
  49. package/Runtime/Core/Messages/IBroadcastMessage.cs +27 -27
  50. package/Runtime/Core/Messages/IBroadcastMessage.cs.meta +11 -11
  51. package/Runtime/Core/Messages/ITargetedMessage.cs +27 -26
  52. package/Runtime/Core/Messages/ITargetedMessage.cs.meta +11 -11
  53. package/Runtime/Core/Messages/IUntargetedMessage.cs +27 -26
  54. package/Runtime/Core/Messages/IUntargetedMessage.cs.meta +11 -11
  55. package/Runtime/Core/Messages.meta +8 -8
  56. package/Runtime/Core/MessagingDebug.cs +70 -71
  57. package/Runtime/Core/MessagingDebug.cs.meta +11 -11
  58. package/Runtime/Core.meta +8 -8
  59. package/Runtime/Unity/MessageAwareComponent.cs +77 -77
  60. package/Runtime/Unity/MessageAwareComponent.cs.meta +11 -11
  61. package/Runtime/Unity/MessagingComponent.cs +99 -99
  62. package/Runtime/Unity/MessagingComponent.cs.meta +11 -11
  63. package/Runtime/Unity.meta +8 -8
  64. package/Runtime/WallstopStudios.DxMessaging.asmdef +15 -15
  65. package/Runtime.meta +8 -8
  66. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxAutoMessageTypeGenerator.cs +92 -75
  67. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxAutoMessageTypeGenerator.cs.meta +11 -11
  68. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxBroadcastMessageGenerator.cs +94 -77
  69. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxBroadcastMessageGenerator.cs.meta +2 -2
  70. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxTargetedMessageGenerator.cs +94 -77
  71. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxTargetedMessageGenerator.cs.meta +2 -2
  72. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxUntargetedMessageGenerator.cs +94 -78
  73. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/DxUntargetedMessageGenerator.cs.meta +2 -2
  74. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.csproj +21 -21
  75. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.csproj.meta +7 -7
  76. package/SourceGenerators/WallstopStudios.DxMessaging.SourceGenerators.meta +8 -8
  77. package/SourceGenerators.meta +8 -8
  78. package/Tests/Runtime/Benchmarks/PerformanceTests.cs +373 -310
  79. package/Tests/Runtime/Benchmarks/PerformanceTests.cs.meta +11 -11
  80. package/Tests/Runtime/Benchmarks.meta +8 -8
  81. package/Tests/Runtime/Core/BroadcastTests.cs +899 -899
  82. package/Tests/Runtime/Core/GlobalAcceptAllTests.cs +190 -169
  83. package/Tests/Runtime/Core/GlobalAcceptAllTests.cs.meta +11 -11
  84. package/Tests/Runtime/Core/MessagingTestBase.cs +185 -164
  85. package/Tests/Runtime/Core/MessagingTestBase.cs.meta +11 -11
  86. package/Tests/Runtime/Core/NominalTests.cs +1740 -1518
  87. package/Tests/Runtime/Core/PostProcessorTests.cs +1236 -849
  88. package/Tests/Runtime/Core/PostProcessorTests.cs.meta +11 -11
  89. package/Tests/Runtime/Core/RegistrationTests.cs +1266 -995
  90. package/Tests/Runtime/Core/RegistrationTests.cs.meta +11 -11
  91. package/Tests/Runtime/Core/TargetedTests.cs +888 -888
  92. package/Tests/Runtime/Core/TargetedTests.cs.meta +11 -11
  93. package/Tests/Runtime/Core/UntargetedTests.cs +272 -272
  94. package/Tests/Runtime/Core/UntargetedTests.cs.meta +11 -11
  95. package/Tests/Runtime/Scripts/Components/EmptyMessageAwareComponent.cs +9 -9
  96. package/Tests/Runtime/Scripts/Components/EmptyMessageAwareComponent.cs.meta +11 -11
  97. package/Tests/Runtime/Scripts/Components/SimpleMessageAwareComponent.cs +186 -140
  98. package/Tests/Runtime/Scripts/Messages/ComplexTargetedMessage.cs +30 -30
  99. package/Tests/Runtime/Scripts/Messages/SimpleBroadcastMessage.cs +8 -8
  100. package/Tests/Runtime/Scripts/Messages/SimpleTargetedMessage.cs +8 -8
  101. package/Tests/Runtime/Scripts/Messages/SimpleUntargetedMessage.cs +8 -8
  102. package/Tests/Runtime/WallstopStudios.DxMessaging.Tests.Runtime.asmdef +22 -22
  103. package/Tests/Runtime/WallstopStudios.DxMessaging.Tests.Runtime.csproj.meta +7 -7
  104. package/Tests.meta +8 -8
  105. package/Third Party Notices.md.meta +7 -7
  106. package/package.json +36 -36
  107. package/package.json.meta +7 -7
package/Tests/Runtime/Core/PostProcessorTests.cs CHANGED
@@ -1,849 +1,1236 @@
1
- namespace DxMessaging.Tests.Runtime.Core
2
- {
3
- using System;
4
- using System.Collections;
5
- using DxMessaging.Core;
6
- using DxMessaging.Core.Extensions;
7
- using Scripts.Messages;
8
- using NUnit.Framework;
9
- using Scripts.Components;
10
- using UnityEngine;
11
- using UnityEngine.TestTools;
12
-
13
- public sealed class PostProcessorTests : MessagingTestBase
14
- {
15
- [UnityTest]
16
- public IEnumerator Untargeted()
17
- {
18
- GameObject test = new(nameof(Untargeted), typeof(EmptyMessageAwareComponent));
19
- _spawned.Add(test);
20
-
21
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
22
- MessageRegistrationToken token = GetToken(component);
23
-
24
- int lastSeenCount = 0;
25
- int count = 0;
26
-
27
- int finalCount = 0;
28
- void ResetCount()
29
- {
30
- lastSeenCount = 0;
31
- count = 0;
32
- finalCount = 0;
33
- }
34
-
35
- Action assertion;
36
-
37
- void PostProcessor(ref SimpleUntargetedMessage message)
38
- {
39
- assertion.Invoke();
40
- }
41
-
42
- count = 1;
43
- assertion = () =>
44
- {
45
- Assert.AreEqual(lastSeenCount + 1, count);
46
- };
47
-
48
- SimpleUntargetedMessage message = new();
49
- Run(() => new[]{token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(PostProcessor)},
50
- () => message.EmitUntargeted(),
51
- () =>
52
- {
53
- lastSeenCount = count++;
54
- finalCount = count;
55
- },
56
- () =>
57
- {
58
- Assert.AreEqual(finalCount - 1, lastSeenCount);
59
- Assert.AreEqual(finalCount, count);
60
- },
61
- token);
62
-
63
- ResetCount();
64
- assertion = () =>
65
- {
66
- Assert.AreEqual(lastSeenCount + 1, count);
67
- lastSeenCount = count;
68
- };
69
- Run(() => new[] { token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(PostProcessor), token.RegisterUntargeted<SimpleUntargetedMessage>(_ => ++count)},
70
- () => message.EmitUntargeted(),
71
- () =>
72
- {
73
- Assert.AreEqual(lastSeenCount, count);
74
- finalCount = count;
75
- },
76
- () =>
77
- {
78
- Assert.AreEqual(finalCount, lastSeenCount);
79
- Assert.AreEqual(finalCount, count);
80
- },
81
- token,
82
- synchronizeDeregistrations: true);
83
-
84
- ResetCount();
85
- assertion = () =>
86
- {
87
- ++count;
88
- };
89
- Run(() => new[] { token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(PostProcessor), token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(PostProcessor)},
90
- () => message.EmitUntargeted(),
91
- () => Assert.AreEqual(++lastSeenCount, count),
92
- () => { Assert.AreEqual(lastSeenCount, count);},
93
- token,
94
- synchronizeDeregistrations: true);
95
-
96
- yield break;
97
- }
98
-
99
- [UnityTest]
100
- public IEnumerator GameObjectTargeted()
101
- {
102
- GameObject test = new(nameof(GameObjectTargeted), typeof(EmptyMessageAwareComponent));
103
- _spawned.Add(test);
104
-
105
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
106
- MessageRegistrationToken token = GetToken(component);
107
-
108
- int lastSeenCount = 0;
109
- int count = 0;
110
-
111
- int finalCount = 0;
112
- void ResetCount()
113
- {
114
- lastSeenCount = 0;
115
- count = 0;
116
- finalCount = 0;
117
- }
118
-
119
- Action assertion;
120
-
121
- void PostProcessor(ref SimpleTargetedMessage message)
122
- {
123
- assertion.Invoke();
124
- }
125
-
126
- count = 1;
127
- assertion = () =>
128
- {
129
- Assert.AreEqual(lastSeenCount + 1, count);
130
- };
131
-
132
- SimpleTargetedMessage message = new();
133
- Run(() => new[] { token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(test, PostProcessor) },
134
- () => message.EmitGameObjectTargeted(test),
135
- () =>
136
- {
137
- lastSeenCount = count++;
138
- finalCount = count;
139
- },
140
- () =>
141
- {
142
- Assert.AreEqual(finalCount - 1, lastSeenCount);
143
- Assert.AreEqual(finalCount, count);
144
- },
145
- token);
146
-
147
- ResetCount();
148
- assertion = () =>
149
- {
150
- Assert.AreEqual(lastSeenCount + 1, count);
151
- lastSeenCount = count;
152
- };
153
- Run(() => new[] { token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(test, PostProcessor), token.RegisterGameObjectTargeted<SimpleTargetedMessage>(test, _ => ++count) },
154
- () => message.EmitGameObjectTargeted(test),
155
- () =>
156
- {
157
- Assert.AreEqual(lastSeenCount, count);
158
- finalCount = count;
159
- },
160
- () =>
161
- {
162
- Assert.AreEqual(finalCount, lastSeenCount);
163
- Assert.AreEqual(finalCount, count);
164
- },
165
- token,
166
- synchronizeDeregistrations: true);
167
-
168
- ResetCount();
169
- assertion = () =>
170
- {
171
- ++count;
172
- };
173
- Run(() => new[] { token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(test, PostProcessor), token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(test, PostProcessor) },
174
- () => message.EmitGameObjectTargeted(test),
175
- () => Assert.AreEqual(++lastSeenCount, count),
176
- () => { Assert.AreEqual(lastSeenCount, count); },
177
- token,
178
- synchronizeDeregistrations: true);
179
-
180
- ResetCount();
181
- assertion = () =>
182
- {
183
- Assert.Fail("Should never be called, we're emitting the wrong thing");
184
- };
185
- Run(() => new[] { token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(test, PostProcessor) },
186
- () => message.EmitComponentTargeted(component),
187
- () =>
188
- {
189
- Assert.AreEqual(0, count);
190
- Assert.AreEqual(0, lastSeenCount);
191
- },
192
- () =>
193
- {
194
- Assert.AreEqual(0, count);
195
- Assert.AreEqual(0, lastSeenCount);
196
- },
197
- token);
198
-
199
- yield break;
200
- }
201
-
202
- [UnityTest]
203
- public IEnumerator GameObjectTargetedWithoutTargeting()
204
- {
205
- GameObject test = new(nameof(GameObjectTargetedWithoutTargeting), typeof(EmptyMessageAwareComponent));
206
- _spawned.Add(test);
207
-
208
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
209
- MessageRegistrationToken token = GetToken(component);
210
-
211
- int lastSeenCount = 0;
212
- int count = 0;
213
-
214
- int finalCount = 0;
215
- void ResetCount()
216
- {
217
- lastSeenCount = 0;
218
- count = 0;
219
- finalCount = 0;
220
- }
221
-
222
- Action assertion;
223
-
224
- void PostProcessor(ref InstanceId target, ref SimpleTargetedMessage message)
225
- {
226
- assertion.Invoke();
227
- }
228
-
229
- count = 1;
230
- assertion = () =>
231
- {
232
- Assert.AreEqual(lastSeenCount + 1, count);
233
- };
234
-
235
- SimpleTargetedMessage message = new();
236
- Run(() => new[] { token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(PostProcessor) },
237
- () => message.EmitGameObjectTargeted(test),
238
- () =>
239
- {
240
- lastSeenCount = count++;
241
- finalCount = count;
242
- },
243
- () =>
244
- {
245
- Assert.AreEqual(finalCount - 1, lastSeenCount);
246
- Assert.AreEqual(finalCount, count);
247
- },
248
- token);
249
-
250
- ResetCount();
251
- assertion = () =>
252
- {
253
- Assert.AreEqual(lastSeenCount + 1, count);
254
- lastSeenCount = count;
255
- };
256
- Run(() => new[] { token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(PostProcessor), token.RegisterGameObjectTargeted<SimpleTargetedMessage>(test, _ => ++count) },
257
- () => message.EmitGameObjectTargeted(test),
258
- () =>
259
- {
260
- Assert.AreEqual(lastSeenCount, count);
261
- finalCount = count;
262
- },
263
- () =>
264
- {
265
- Assert.AreEqual(finalCount, lastSeenCount);
266
- Assert.AreEqual(finalCount, count);
267
- },
268
- token,
269
- synchronizeDeregistrations: true);
270
-
271
- ResetCount();
272
- assertion = () =>
273
- {
274
- ++count;
275
- };
276
- Run(() => new[] { token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(PostProcessor), token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(PostProcessor) },
277
- () => message.EmitGameObjectTargeted(test),
278
- () => Assert.AreEqual(++lastSeenCount, count),
279
- () => { Assert.AreEqual(lastSeenCount, count); },
280
- token,
281
- synchronizeDeregistrations: true);
282
-
283
- yield break;
284
- }
285
-
286
- [UnityTest]
287
- public IEnumerator ComponentTargeted()
288
- {
289
- GameObject test = new(nameof(ComponentTargeted), typeof(EmptyMessageAwareComponent));
290
- _spawned.Add(test);
291
-
292
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
293
- MessageRegistrationToken token = GetToken(component);
294
-
295
- int lastSeenCount = 0;
296
- int count = 0;
297
-
298
- int finalCount = 0;
299
- void ResetCount()
300
- {
301
- lastSeenCount = 0;
302
- count = 0;
303
- finalCount = 0;
304
- }
305
-
306
- Action assertion;
307
-
308
- void PostProcessor(ref SimpleTargetedMessage message)
309
- {
310
- assertion.Invoke();
311
- }
312
-
313
- count = 1;
314
- assertion = () =>
315
- {
316
- Assert.AreEqual(lastSeenCount + 1, count);
317
- };
318
-
319
- SimpleTargetedMessage message = new();
320
- Run(() => new[] { token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(component, PostProcessor) },
321
- () => message.EmitComponentTargeted(component),
322
- () =>
323
- {
324
- lastSeenCount = count++;
325
- finalCount = count;
326
- },
327
- () =>
328
- {
329
- Assert.AreEqual(finalCount - 1, lastSeenCount);
330
- Assert.AreEqual(finalCount, count);
331
- },
332
- token);
333
-
334
- ResetCount();
335
- assertion = () =>
336
- {
337
- Assert.AreEqual(lastSeenCount + 1, count);
338
- lastSeenCount = count;
339
- };
340
- Run(() => new[] { token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(component, PostProcessor), token.RegisterComponentTargeted<SimpleTargetedMessage>(component, _ => ++count) },
341
- () => message.EmitComponentTargeted(component),
342
- () =>
343
- {
344
- Assert.AreEqual(lastSeenCount, count);
345
- finalCount = count;
346
- },
347
- () =>
348
- {
349
- Assert.AreEqual(finalCount, lastSeenCount);
350
- Assert.AreEqual(finalCount, count);
351
- },
352
- token,
353
- synchronizeDeregistrations: true);
354
-
355
- ResetCount();
356
- assertion = () =>
357
- {
358
- ++count;
359
- };
360
- Run(() => new[] { token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(component, PostProcessor), token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(component, PostProcessor) },
361
- () => message.EmitComponentTargeted(component),
362
- () => Assert.AreEqual(++lastSeenCount, count),
363
- () => { Assert.AreEqual(lastSeenCount, count); },
364
- token,
365
- synchronizeDeregistrations: true);
366
-
367
- ResetCount();
368
- assertion = () =>
369
- {
370
- Assert.Fail("Should never be called, we're emitting the wrong thing");
371
- };
372
- Run(() => new[] { token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(component, PostProcessor)},
373
- () => message.EmitGameObjectTargeted(test),
374
- () =>
375
- {
376
- Assert.AreEqual(0, count);
377
- Assert.AreEqual(0, lastSeenCount);
378
- },
379
- () =>
380
- {
381
- Assert.AreEqual(0, count);
382
- Assert.AreEqual(0, lastSeenCount);
383
- },
384
- token);
385
-
386
- yield break;
387
- }
388
-
389
- [UnityTest]
390
- public IEnumerator ComponentTargetedWithoutTargeting()
391
- {
392
- GameObject test = new(nameof(ComponentTargetedWithoutTargeting), typeof(EmptyMessageAwareComponent));
393
- _spawned.Add(test);
394
-
395
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
396
- MessageRegistrationToken token = GetToken(component);
397
-
398
- int lastSeenCount = 0;
399
- int count = 0;
400
-
401
- int finalCount = 0;
402
- void ResetCount()
403
- {
404
- lastSeenCount = 0;
405
- count = 0;
406
- finalCount = 0;
407
- }
408
-
409
- Action assertion;
410
-
411
- void PostProcessor(ref InstanceId target, ref SimpleTargetedMessage message)
412
- {
413
- assertion.Invoke();
414
- }
415
-
416
- count = 1;
417
- assertion = () =>
418
- {
419
- Assert.AreEqual(lastSeenCount + 1, count);
420
- };
421
-
422
- SimpleTargetedMessage message = new();
423
- Run(() => new[] { token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(PostProcessor) },
424
- () => message.EmitComponentTargeted(component),
425
- () =>
426
- {
427
- lastSeenCount = count++;
428
- finalCount = count;
429
- },
430
- () =>
431
- {
432
- Assert.AreEqual(finalCount - 1, lastSeenCount);
433
- Assert.AreEqual(finalCount, count);
434
- },
435
- token);
436
-
437
- ResetCount();
438
- assertion = () =>
439
- {
440
- Assert.AreEqual(lastSeenCount + 1, count);
441
- lastSeenCount = count;
442
- };
443
- Run(() => new[] { token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(PostProcessor), token.RegisterComponentTargeted<SimpleTargetedMessage>(component, _ => ++count) },
444
- () => message.EmitComponentTargeted(component),
445
- () =>
446
- {
447
- Assert.AreEqual(lastSeenCount, count);
448
- finalCount = count;
449
- },
450
- () =>
451
- {
452
- Assert.AreEqual(finalCount, lastSeenCount);
453
- Assert.AreEqual(finalCount, count);
454
- },
455
- token,
456
- synchronizeDeregistrations: true);
457
-
458
- ResetCount();
459
- assertion = () =>
460
- {
461
- ++count;
462
- };
463
- Run(() => new[] { token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(PostProcessor), token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(PostProcessor) },
464
- () => message.EmitComponentTargeted(component),
465
- () => Assert.AreEqual(++lastSeenCount, count),
466
- () => { Assert.AreEqual(lastSeenCount, count); },
467
- token,
468
- synchronizeDeregistrations: true);
469
-
470
- ResetCount();
471
-
472
- yield break;
473
- }
474
-
475
- [UnityTest]
476
- public IEnumerator GameObjectBroadcast()
477
- {
478
- GameObject test = new(nameof(GameObjectBroadcast), typeof(EmptyMessageAwareComponent));
479
- _spawned.Add(test);
480
-
481
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
482
- MessageRegistrationToken token = GetToken(component);
483
-
484
- int lastSeenCount = 0;
485
- int count = 0;
486
-
487
- int finalCount = 0;
488
- void ResetCount()
489
- {
490
- lastSeenCount = 0;
491
- count = 0;
492
- finalCount = 0;
493
- }
494
-
495
- Action assertion;
496
-
497
- void PostProcessor(ref SimpleBroadcastMessage message)
498
- {
499
- assertion.Invoke();
500
- }
501
-
502
- count = 1;
503
- assertion = () =>
504
- {
505
- Assert.AreEqual(lastSeenCount + 1, count);
506
- };
507
-
508
- SimpleBroadcastMessage message = new();
509
- Run(() => new[] { token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(test, PostProcessor) },
510
- () => message.EmitGameObjectBroadcast(test),
511
- () =>
512
- {
513
- lastSeenCount = count++;
514
- finalCount = count;
515
- },
516
- () =>
517
- {
518
- Assert.AreEqual(finalCount - 1, lastSeenCount);
519
- Assert.AreEqual(finalCount, count);
520
- },
521
- token);
522
-
523
- ResetCount();
524
- assertion = () =>
525
- {
526
- Assert.AreEqual(lastSeenCount + 1, count, "GameObjectBroadcast was not handled!");
527
- lastSeenCount = count;
528
- };
529
- Run(() => new[] { token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(test, PostProcessor), token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(test, _ => ++count) },
530
- () => message.EmitGameObjectBroadcast(test),
531
- () =>
532
- {
533
- Assert.AreEqual(lastSeenCount, count, "GameObjectBroadcast PostProcessor was not run!");
534
- finalCount = count;
535
- },
536
- () =>
537
- {
538
- Assert.AreEqual(finalCount, lastSeenCount);
539
- Assert.AreEqual(finalCount, count);
540
- },
541
- token,
542
- synchronizeDeregistrations: true);
543
-
544
- ResetCount();
545
- assertion = () =>
546
- {
547
- ++count;
548
- };
549
- Run(() => new[] { token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(test, PostProcessor), token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(test, PostProcessor) },
550
- () => message.EmitGameObjectBroadcast(test),
551
- () => Assert.AreEqual(++lastSeenCount, count, "GameObjectBroadcast PostProcessor was ran twice!"),
552
- () => { Assert.AreEqual(lastSeenCount, count, "GameObjectPostProcessor ran without any receivers subscribed!"); },
553
- token,
554
- synchronizeDeregistrations: true);
555
-
556
- ResetCount();
557
- assertion = () =>
558
- {
559
- Assert.Fail("Should never be called, we're emitting the wrong thing");
560
- };
561
- Run(() => new[] { token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(test, PostProcessor)},
562
- () => message.EmitComponentBroadcast(component),
563
- () =>
564
- {
565
- Assert.AreEqual(0, count);
566
- Assert.AreEqual(0, lastSeenCount);
567
- },
568
- () =>
569
- {
570
- Assert.AreEqual(0, count);
571
- Assert.AreEqual(0, lastSeenCount);
572
- },
573
- token);
574
-
575
- yield break;
576
- }
577
-
578
- [UnityTest]
579
- public IEnumerator GameObjectBroadcastWithoutSource()
580
- {
581
- GameObject test = new(nameof(GameObjectBroadcastWithoutSource), typeof(EmptyMessageAwareComponent));
582
- _spawned.Add(test);
583
-
584
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
585
- MessageRegistrationToken token = GetToken(component);
586
-
587
- int lastSeenCount = 0;
588
- int count = 0;
589
-
590
- int finalCount = 0;
591
- void ResetCount()
592
- {
593
- lastSeenCount = 0;
594
- count = 0;
595
- finalCount = 0;
596
- }
597
-
598
- Action assertion;
599
-
600
- void PostProcessor(ref InstanceId target, ref SimpleBroadcastMessage message)
601
- {
602
- assertion.Invoke();
603
- }
604
-
605
- count = 1;
606
- assertion = () =>
607
- {
608
- Assert.AreEqual(lastSeenCount + 1, count);
609
- };
610
-
611
- SimpleBroadcastMessage message = new();
612
- Run(() => new[] { token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor) },
613
- () => message.EmitGameObjectBroadcast(test),
614
- () =>
615
- {
616
- lastSeenCount = count++;
617
- finalCount = count;
618
- },
619
- () =>
620
- {
621
- Assert.AreEqual(finalCount - 1, lastSeenCount);
622
- Assert.AreEqual(finalCount, count);
623
- },
624
- token);
625
-
626
- ResetCount();
627
- assertion = () =>
628
- {
629
- Assert.AreEqual(lastSeenCount + 1, count, "GameObjectBroadcast was not handled!");
630
- lastSeenCount = count;
631
- };
632
- Run(() => new[] { token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor), token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(test, _ => ++count) },
633
- () => message.EmitGameObjectBroadcast(test),
634
- () =>
635
- {
636
- Assert.AreEqual(lastSeenCount, count, "GameObjectBroadcast PostProcessor was not run!");
637
- finalCount = count;
638
- },
639
- () =>
640
- {
641
- Assert.AreEqual(finalCount, lastSeenCount);
642
- Assert.AreEqual(finalCount, count);
643
- },
644
- token,
645
- synchronizeDeregistrations: true);
646
-
647
- ResetCount();
648
- assertion = () =>
649
- {
650
- ++count;
651
- };
652
- Run(() => new[] { token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor), token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor) },
653
- () => message.EmitGameObjectBroadcast(test),
654
- () => Assert.AreEqual(++lastSeenCount, count, "GameObjectBroadcast PostProcessor was ran twice!"),
655
- () => { Assert.AreEqual(lastSeenCount, count, "GameObjectPostProcessor ran without any receivers subscribed!"); },
656
- token,
657
- synchronizeDeregistrations: true);
658
-
659
- yield break;
660
- }
661
-
662
- [UnityTest]
663
- public IEnumerator ComponentBroadcast()
664
- {
665
- GameObject test = new(nameof(ComponentBroadcast), typeof(EmptyMessageAwareComponent));
666
- _spawned.Add(test);
667
-
668
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
669
- MessageRegistrationToken token = GetToken(component);
670
-
671
- int lastSeenCount = 0;
672
- int count = 0;
673
-
674
- int finalCount = 0;
675
- void ResetCount()
676
- {
677
- lastSeenCount = 0;
678
- count = 0;
679
- finalCount = 0;
680
- }
681
-
682
- Action assertion;
683
-
684
- void PostProcessor(ref SimpleBroadcastMessage message)
685
- {
686
- assertion.Invoke();
687
- }
688
-
689
- count = 1;
690
- assertion = () =>
691
- {
692
- Assert.AreEqual(lastSeenCount + 1, count);
693
- };
694
-
695
- SimpleBroadcastMessage message = new();
696
- Run(() => new[] { token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(component, PostProcessor) },
697
- () => message.EmitComponentBroadcast(component),
698
- () =>
699
- {
700
- lastSeenCount = count++;
701
- finalCount = count;
702
- },
703
- () =>
704
- {
705
- Assert.AreEqual(finalCount - 1, lastSeenCount);
706
- Assert.AreEqual(finalCount, count);
707
- },
708
- token);
709
-
710
- ResetCount();
711
- assertion = () =>
712
- {
713
- Assert.AreEqual(lastSeenCount + 1, count);
714
- lastSeenCount = count;
715
- };
716
- Run(() => new[] { token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(component, PostProcessor), token.RegisterComponentBroadcast<SimpleBroadcastMessage>(component, _ => ++count) },
717
- () => message.EmitComponentBroadcast(component),
718
- () =>
719
- {
720
- Assert.AreEqual(lastSeenCount, count);
721
- finalCount = count;
722
- },
723
- () =>
724
- {
725
- Assert.AreEqual(finalCount, lastSeenCount);
726
- Assert.AreEqual(finalCount, count);
727
- },
728
- token,
729
- synchronizeDeregistrations: true);
730
-
731
- ResetCount();
732
- assertion = () =>
733
- {
734
- ++count;
735
- };
736
- Run(() => new[] { token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(component, PostProcessor), token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(component, PostProcessor) },
737
- () => message.EmitComponentBroadcast(component),
738
- () => Assert.AreEqual(++lastSeenCount, count),
739
- () => { Assert.AreEqual(lastSeenCount, count); },
740
- token,
741
- synchronizeDeregistrations: true);
742
-
743
- ResetCount();
744
- assertion = () =>
745
- {
746
- Assert.Fail("Should never be called, we're emitting the wrong thing");
747
- };
748
- Run(() => new[] { token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(component, PostProcessor) },
749
- () => message.EmitGameObjectBroadcast(test),
750
- () =>
751
- {
752
- Assert.AreEqual(0, count);
753
- Assert.AreEqual(0, lastSeenCount);
754
- },
755
- () =>
756
- {
757
- Assert.AreEqual(0, count);
758
- Assert.AreEqual(0, lastSeenCount);
759
- },
760
- token);
761
-
762
- yield break;
763
- }
764
-
765
- [UnityTest]
766
- public IEnumerator ComponentBroadcastWithoutSource()
767
- {
768
- GameObject test = new(nameof(ComponentBroadcastWithoutSource), typeof(EmptyMessageAwareComponent));
769
- _spawned.Add(test);
770
-
771
- EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
772
- MessageRegistrationToken token = GetToken(component);
773
-
774
- int lastSeenCount = 0;
775
- int count = 0;
776
-
777
- int finalCount = 0;
778
- void ResetCount()
779
- {
780
- lastSeenCount = 0;
781
- count = 0;
782
- finalCount = 0;
783
- }
784
-
785
- Action assertion;
786
-
787
- void PostProcessor(ref InstanceId source, ref SimpleBroadcastMessage message)
788
- {
789
- assertion.Invoke();
790
- }
791
-
792
- count = 1;
793
- assertion = () =>
794
- {
795
- Assert.AreEqual(lastSeenCount + 1, count);
796
- };
797
-
798
- SimpleBroadcastMessage message = new();
799
- Run(() => new[] { token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor) },
800
- () => message.EmitComponentBroadcast(component),
801
- () =>
802
- {
803
- lastSeenCount = count++;
804
- finalCount = count;
805
- },
806
- () =>
807
- {
808
- Assert.AreEqual(finalCount - 1, lastSeenCount);
809
- Assert.AreEqual(finalCount, count);
810
- },
811
- token);
812
-
813
- ResetCount();
814
- assertion = () =>
815
- {
816
- Assert.AreEqual(lastSeenCount + 1, count);
817
- lastSeenCount = count;
818
- };
819
- Run(() => new[] { token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor), token.RegisterComponentBroadcast<SimpleBroadcastMessage>(component, _ => ++count) },
820
- () => message.EmitComponentBroadcast(component),
821
- () =>
822
- {
823
- Assert.AreEqual(lastSeenCount, count);
824
- finalCount = count;
825
- },
826
- () =>
827
- {
828
- Assert.AreEqual(finalCount, lastSeenCount);
829
- Assert.AreEqual(finalCount, count);
830
- },
831
- token,
832
- synchronizeDeregistrations: true);
833
-
834
- ResetCount();
835
- assertion = () =>
836
- {
837
- ++count;
838
- };
839
- Run(() => new[] { token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor), token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(PostProcessor) },
840
- () => message.EmitComponentBroadcast(component),
841
- () => Assert.AreEqual(++lastSeenCount, count),
842
- () => { Assert.AreEqual(lastSeenCount, count); },
843
- token,
844
- synchronizeDeregistrations: true);
845
-
846
- yield break;
847
- }
848
- }
849
- }
1
+ namespace DxMessaging.Tests.Runtime.Core
2
+ {
3
+ using System;
4
+ using System.Collections;
5
+ using DxMessaging.Core;
6
+ using DxMessaging.Core.Extensions;
7
+ using NUnit.Framework;
8
+ using Scripts.Components;
9
+ using Scripts.Messages;
10
+ using UnityEngine;
11
+ using UnityEngine.TestTools;
12
+
13
+ public sealed class PostProcessorTests : MessagingTestBase
14
+ {
15
+ [UnityTest]
16
+ public IEnumerator Untargeted()
17
+ {
18
+ GameObject test = new(nameof(Untargeted), typeof(EmptyMessageAwareComponent));
19
+ _spawned.Add(test);
20
+
21
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
22
+ MessageRegistrationToken token = GetToken(component);
23
+
24
+ int lastSeenCount = 0;
25
+ int count = 0;
26
+
27
+ int finalCount = 0;
28
+ void ResetCount()
29
+ {
30
+ lastSeenCount = 0;
31
+ count = 0;
32
+ finalCount = 0;
33
+ }
34
+
35
+ Action assertion;
36
+
37
+ void PostProcessor(ref SimpleUntargetedMessage message)
38
+ {
39
+ assertion.Invoke();
40
+ }
41
+
42
+ count = 1;
43
+ assertion = () =>
44
+ {
45
+ Assert.AreEqual(lastSeenCount + 1, count);
46
+ };
47
+
48
+ SimpleUntargetedMessage message = new();
49
+ Run(
50
+ () =>
51
+ new[]
52
+ {
53
+ token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
54
+ PostProcessor
55
+ ),
56
+ },
57
+ () => message.EmitUntargeted(),
58
+ () =>
59
+ {
60
+ lastSeenCount = count++;
61
+ finalCount = count;
62
+ },
63
+ () =>
64
+ {
65
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
66
+ Assert.AreEqual(finalCount, count);
67
+ },
68
+ token
69
+ );
70
+
71
+ ResetCount();
72
+ assertion = () =>
73
+ {
74
+ Assert.AreEqual(lastSeenCount + 1, count);
75
+ lastSeenCount = count;
76
+ };
77
+ Run(
78
+ () =>
79
+ new[]
80
+ {
81
+ token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
82
+ PostProcessor
83
+ ),
84
+ token.RegisterUntargeted<SimpleUntargetedMessage>(_ => ++count),
85
+ },
86
+ () => message.EmitUntargeted(),
87
+ () =>
88
+ {
89
+ Assert.AreEqual(lastSeenCount, count);
90
+ finalCount = count;
91
+ },
92
+ () =>
93
+ {
94
+ Assert.AreEqual(finalCount, lastSeenCount);
95
+ Assert.AreEqual(finalCount, count);
96
+ },
97
+ token,
98
+ synchronizeDeregistrations: true
99
+ );
100
+
101
+ ResetCount();
102
+ assertion = () =>
103
+ {
104
+ ++count;
105
+ };
106
+ Run(
107
+ () =>
108
+ new[]
109
+ {
110
+ token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
111
+ PostProcessor
112
+ ),
113
+ token.RegisterUntargetedPostProcessor<SimpleUntargetedMessage>(
114
+ PostProcessor
115
+ ),
116
+ },
117
+ () => message.EmitUntargeted(),
118
+ () => Assert.AreEqual(++lastSeenCount, count),
119
+ () =>
120
+ {
121
+ Assert.AreEqual(lastSeenCount, count);
122
+ },
123
+ token,
124
+ synchronizeDeregistrations: true
125
+ );
126
+
127
+ yield break;
128
+ }
129
+
130
+ [UnityTest]
131
+ public IEnumerator GameObjectTargeted()
132
+ {
133
+ GameObject test = new(nameof(GameObjectTargeted), typeof(EmptyMessageAwareComponent));
134
+ _spawned.Add(test);
135
+
136
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
137
+ MessageRegistrationToken token = GetToken(component);
138
+
139
+ int lastSeenCount = 0;
140
+ int count = 0;
141
+
142
+ int finalCount = 0;
143
+ void ResetCount()
144
+ {
145
+ lastSeenCount = 0;
146
+ count = 0;
147
+ finalCount = 0;
148
+ }
149
+
150
+ Action assertion;
151
+
152
+ void PostProcessor(ref SimpleTargetedMessage message)
153
+ {
154
+ assertion.Invoke();
155
+ }
156
+
157
+ count = 1;
158
+ assertion = () =>
159
+ {
160
+ Assert.AreEqual(lastSeenCount + 1, count);
161
+ };
162
+
163
+ SimpleTargetedMessage message = new();
164
+ Run(
165
+ () =>
166
+ new[]
167
+ {
168
+ token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(
169
+ test,
170
+ PostProcessor
171
+ ),
172
+ },
173
+ () => message.EmitGameObjectTargeted(test),
174
+ () =>
175
+ {
176
+ lastSeenCount = count++;
177
+ finalCount = count;
178
+ },
179
+ () =>
180
+ {
181
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
182
+ Assert.AreEqual(finalCount, count);
183
+ },
184
+ token
185
+ );
186
+
187
+ ResetCount();
188
+ assertion = () =>
189
+ {
190
+ Assert.AreEqual(lastSeenCount + 1, count);
191
+ lastSeenCount = count;
192
+ };
193
+ Run(
194
+ () =>
195
+ new[]
196
+ {
197
+ token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(
198
+ test,
199
+ PostProcessor
200
+ ),
201
+ token.RegisterGameObjectTargeted<SimpleTargetedMessage>(test, _ => ++count),
202
+ },
203
+ () => message.EmitGameObjectTargeted(test),
204
+ () =>
205
+ {
206
+ Assert.AreEqual(lastSeenCount, count);
207
+ finalCount = count;
208
+ },
209
+ () =>
210
+ {
211
+ Assert.AreEqual(finalCount, lastSeenCount);
212
+ Assert.AreEqual(finalCount, count);
213
+ },
214
+ token,
215
+ synchronizeDeregistrations: true
216
+ );
217
+
218
+ ResetCount();
219
+ assertion = () =>
220
+ {
221
+ ++count;
222
+ };
223
+ Run(
224
+ () =>
225
+ new[]
226
+ {
227
+ token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(
228
+ test,
229
+ PostProcessor
230
+ ),
231
+ token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(
232
+ test,
233
+ PostProcessor
234
+ ),
235
+ },
236
+ () => message.EmitGameObjectTargeted(test),
237
+ () => Assert.AreEqual(++lastSeenCount, count),
238
+ () =>
239
+ {
240
+ Assert.AreEqual(lastSeenCount, count);
241
+ },
242
+ token,
243
+ synchronizeDeregistrations: true
244
+ );
245
+
246
+ ResetCount();
247
+ assertion = () =>
248
+ {
249
+ Assert.Fail("Should never be called, we're emitting the wrong thing");
250
+ };
251
+ Run(
252
+ () =>
253
+ new[]
254
+ {
255
+ token.RegisterGameObjectTargetedPostProcessor<SimpleTargetedMessage>(
256
+ test,
257
+ PostProcessor
258
+ ),
259
+ },
260
+ () => message.EmitComponentTargeted(component),
261
+ () =>
262
+ {
263
+ Assert.AreEqual(0, count);
264
+ Assert.AreEqual(0, lastSeenCount);
265
+ },
266
+ () =>
267
+ {
268
+ Assert.AreEqual(0, count);
269
+ Assert.AreEqual(0, lastSeenCount);
270
+ },
271
+ token
272
+ );
273
+
274
+ yield break;
275
+ }
276
+
277
+ [UnityTest]
278
+ public IEnumerator GameObjectTargetedWithoutTargeting()
279
+ {
280
+ GameObject test = new(
281
+ nameof(GameObjectTargetedWithoutTargeting),
282
+ typeof(EmptyMessageAwareComponent)
283
+ );
284
+ _spawned.Add(test);
285
+
286
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
287
+ MessageRegistrationToken token = GetToken(component);
288
+
289
+ int lastSeenCount = 0;
290
+ int count = 0;
291
+
292
+ int finalCount = 0;
293
+ void ResetCount()
294
+ {
295
+ lastSeenCount = 0;
296
+ count = 0;
297
+ finalCount = 0;
298
+ }
299
+
300
+ Action assertion;
301
+
302
+ void PostProcessor(ref InstanceId target, ref SimpleTargetedMessage message)
303
+ {
304
+ assertion.Invoke();
305
+ }
306
+
307
+ count = 1;
308
+ assertion = () =>
309
+ {
310
+ Assert.AreEqual(lastSeenCount + 1, count);
311
+ };
312
+
313
+ SimpleTargetedMessage message = new();
314
+ Run(
315
+ () =>
316
+ new[]
317
+ {
318
+ token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(
319
+ PostProcessor
320
+ ),
321
+ },
322
+ () => message.EmitGameObjectTargeted(test),
323
+ () =>
324
+ {
325
+ lastSeenCount = count++;
326
+ finalCount = count;
327
+ },
328
+ () =>
329
+ {
330
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
331
+ Assert.AreEqual(finalCount, count);
332
+ },
333
+ token
334
+ );
335
+
336
+ ResetCount();
337
+ assertion = () =>
338
+ {
339
+ Assert.AreEqual(lastSeenCount + 1, count);
340
+ lastSeenCount = count;
341
+ };
342
+ Run(
343
+ () =>
344
+ new[]
345
+ {
346
+ token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(
347
+ PostProcessor
348
+ ),
349
+ token.RegisterGameObjectTargeted<SimpleTargetedMessage>(test, _ => ++count),
350
+ },
351
+ () => message.EmitGameObjectTargeted(test),
352
+ () =>
353
+ {
354
+ Assert.AreEqual(lastSeenCount, count);
355
+ finalCount = count;
356
+ },
357
+ () =>
358
+ {
359
+ Assert.AreEqual(finalCount, lastSeenCount);
360
+ Assert.AreEqual(finalCount, count);
361
+ },
362
+ token,
363
+ synchronizeDeregistrations: true
364
+ );
365
+
366
+ ResetCount();
367
+ assertion = () =>
368
+ {
369
+ ++count;
370
+ };
371
+ Run(
372
+ () =>
373
+ new[]
374
+ {
375
+ token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(
376
+ PostProcessor
377
+ ),
378
+ token.RegisterTargetedWithoutTargeting<SimpleTargetedMessage>(
379
+ PostProcessor
380
+ ),
381
+ },
382
+ () => message.EmitGameObjectTargeted(test),
383
+ () => Assert.AreEqual(++lastSeenCount, count),
384
+ () =>
385
+ {
386
+ Assert.AreEqual(lastSeenCount, count);
387
+ },
388
+ token,
389
+ synchronizeDeregistrations: true
390
+ );
391
+
392
+ yield break;
393
+ }
394
+
395
+ [UnityTest]
396
+ public IEnumerator ComponentTargeted()
397
+ {
398
+ GameObject test = new(nameof(ComponentTargeted), typeof(EmptyMessageAwareComponent));
399
+ _spawned.Add(test);
400
+
401
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
402
+ MessageRegistrationToken token = GetToken(component);
403
+
404
+ int lastSeenCount = 0;
405
+ int count = 0;
406
+
407
+ int finalCount = 0;
408
+ void ResetCount()
409
+ {
410
+ lastSeenCount = 0;
411
+ count = 0;
412
+ finalCount = 0;
413
+ }
414
+
415
+ Action assertion;
416
+
417
+ void PostProcessor(ref SimpleTargetedMessage message)
418
+ {
419
+ assertion.Invoke();
420
+ }
421
+
422
+ count = 1;
423
+ assertion = () =>
424
+ {
425
+ Assert.AreEqual(lastSeenCount + 1, count);
426
+ };
427
+
428
+ SimpleTargetedMessage message = new();
429
+ Run(
430
+ () =>
431
+ new[]
432
+ {
433
+ token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(
434
+ component,
435
+ PostProcessor
436
+ ),
437
+ },
438
+ () => message.EmitComponentTargeted(component),
439
+ () =>
440
+ {
441
+ lastSeenCount = count++;
442
+ finalCount = count;
443
+ },
444
+ () =>
445
+ {
446
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
447
+ Assert.AreEqual(finalCount, count);
448
+ },
449
+ token
450
+ );
451
+
452
+ ResetCount();
453
+ assertion = () =>
454
+ {
455
+ Assert.AreEqual(lastSeenCount + 1, count);
456
+ lastSeenCount = count;
457
+ };
458
+ Run(
459
+ () =>
460
+ new[]
461
+ {
462
+ token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(
463
+ component,
464
+ PostProcessor
465
+ ),
466
+ token.RegisterComponentTargeted<SimpleTargetedMessage>(
467
+ component,
468
+ _ => ++count
469
+ ),
470
+ },
471
+ () => message.EmitComponentTargeted(component),
472
+ () =>
473
+ {
474
+ Assert.AreEqual(lastSeenCount, count);
475
+ finalCount = count;
476
+ },
477
+ () =>
478
+ {
479
+ Assert.AreEqual(finalCount, lastSeenCount);
480
+ Assert.AreEqual(finalCount, count);
481
+ },
482
+ token,
483
+ synchronizeDeregistrations: true
484
+ );
485
+
486
+ ResetCount();
487
+ assertion = () =>
488
+ {
489
+ ++count;
490
+ };
491
+ Run(
492
+ () =>
493
+ new[]
494
+ {
495
+ token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(
496
+ component,
497
+ PostProcessor
498
+ ),
499
+ token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(
500
+ component,
501
+ PostProcessor
502
+ ),
503
+ },
504
+ () => message.EmitComponentTargeted(component),
505
+ () => Assert.AreEqual(++lastSeenCount, count),
506
+ () =>
507
+ {
508
+ Assert.AreEqual(lastSeenCount, count);
509
+ },
510
+ token,
511
+ synchronizeDeregistrations: true
512
+ );
513
+
514
+ ResetCount();
515
+ assertion = () =>
516
+ {
517
+ Assert.Fail("Should never be called, we're emitting the wrong thing");
518
+ };
519
+ Run(
520
+ () =>
521
+ new[]
522
+ {
523
+ token.RegisterComponentTargetedPostProcessor<SimpleTargetedMessage>(
524
+ component,
525
+ PostProcessor
526
+ ),
527
+ },
528
+ () => message.EmitGameObjectTargeted(test),
529
+ () =>
530
+ {
531
+ Assert.AreEqual(0, count);
532
+ Assert.AreEqual(0, lastSeenCount);
533
+ },
534
+ () =>
535
+ {
536
+ Assert.AreEqual(0, count);
537
+ Assert.AreEqual(0, lastSeenCount);
538
+ },
539
+ token
540
+ );
541
+
542
+ yield break;
543
+ }
544
+
545
+ [UnityTest]
546
+ public IEnumerator ComponentTargetedWithoutTargeting()
547
+ {
548
+ GameObject test = new(
549
+ nameof(ComponentTargetedWithoutTargeting),
550
+ typeof(EmptyMessageAwareComponent)
551
+ );
552
+ _spawned.Add(test);
553
+
554
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
555
+ MessageRegistrationToken token = GetToken(component);
556
+
557
+ int lastSeenCount = 0;
558
+ int count = 0;
559
+
560
+ int finalCount = 0;
561
+ void ResetCount()
562
+ {
563
+ lastSeenCount = 0;
564
+ count = 0;
565
+ finalCount = 0;
566
+ }
567
+
568
+ Action assertion;
569
+
570
+ void PostProcessor(ref InstanceId target, ref SimpleTargetedMessage message)
571
+ {
572
+ assertion.Invoke();
573
+ }
574
+
575
+ count = 1;
576
+ assertion = () =>
577
+ {
578
+ Assert.AreEqual(lastSeenCount + 1, count);
579
+ };
580
+
581
+ SimpleTargetedMessage message = new();
582
+ Run(
583
+ () =>
584
+ new[]
585
+ {
586
+ token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(
587
+ PostProcessor
588
+ ),
589
+ },
590
+ () => message.EmitComponentTargeted(component),
591
+ () =>
592
+ {
593
+ lastSeenCount = count++;
594
+ finalCount = count;
595
+ },
596
+ () =>
597
+ {
598
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
599
+ Assert.AreEqual(finalCount, count);
600
+ },
601
+ token
602
+ );
603
+
604
+ ResetCount();
605
+ assertion = () =>
606
+ {
607
+ Assert.AreEqual(lastSeenCount + 1, count);
608
+ lastSeenCount = count;
609
+ };
610
+ Run(
611
+ () =>
612
+ new[]
613
+ {
614
+ token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(
615
+ PostProcessor
616
+ ),
617
+ token.RegisterComponentTargeted<SimpleTargetedMessage>(
618
+ component,
619
+ _ => ++count
620
+ ),
621
+ },
622
+ () => message.EmitComponentTargeted(component),
623
+ () =>
624
+ {
625
+ Assert.AreEqual(lastSeenCount, count);
626
+ finalCount = count;
627
+ },
628
+ () =>
629
+ {
630
+ Assert.AreEqual(finalCount, lastSeenCount);
631
+ Assert.AreEqual(finalCount, count);
632
+ },
633
+ token,
634
+ synchronizeDeregistrations: true
635
+ );
636
+
637
+ ResetCount();
638
+ assertion = () =>
639
+ {
640
+ ++count;
641
+ };
642
+ Run(
643
+ () =>
644
+ new[]
645
+ {
646
+ token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(
647
+ PostProcessor
648
+ ),
649
+ token.RegisterTargetedWithoutTargetingPostProcessor<SimpleTargetedMessage>(
650
+ PostProcessor
651
+ ),
652
+ },
653
+ () => message.EmitComponentTargeted(component),
654
+ () => Assert.AreEqual(++lastSeenCount, count),
655
+ () =>
656
+ {
657
+ Assert.AreEqual(lastSeenCount, count);
658
+ },
659
+ token,
660
+ synchronizeDeregistrations: true
661
+ );
662
+
663
+ ResetCount();
664
+
665
+ yield break;
666
+ }
667
+
668
+ [UnityTest]
669
+ public IEnumerator GameObjectBroadcast()
670
+ {
671
+ GameObject test = new(nameof(GameObjectBroadcast), typeof(EmptyMessageAwareComponent));
672
+ _spawned.Add(test);
673
+
674
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
675
+ MessageRegistrationToken token = GetToken(component);
676
+
677
+ int lastSeenCount = 0;
678
+ int count = 0;
679
+
680
+ int finalCount = 0;
681
+ void ResetCount()
682
+ {
683
+ lastSeenCount = 0;
684
+ count = 0;
685
+ finalCount = 0;
686
+ }
687
+
688
+ Action assertion;
689
+
690
+ void PostProcessor(ref SimpleBroadcastMessage message)
691
+ {
692
+ assertion.Invoke();
693
+ }
694
+
695
+ count = 1;
696
+ assertion = () =>
697
+ {
698
+ Assert.AreEqual(lastSeenCount + 1, count);
699
+ };
700
+
701
+ SimpleBroadcastMessage message = new();
702
+ Run(
703
+ () =>
704
+ new[]
705
+ {
706
+ token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(
707
+ test,
708
+ PostProcessor
709
+ ),
710
+ },
711
+ () => message.EmitGameObjectBroadcast(test),
712
+ () =>
713
+ {
714
+ lastSeenCount = count++;
715
+ finalCount = count;
716
+ },
717
+ () =>
718
+ {
719
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
720
+ Assert.AreEqual(finalCount, count);
721
+ },
722
+ token
723
+ );
724
+
725
+ ResetCount();
726
+ assertion = () =>
727
+ {
728
+ Assert.AreEqual(lastSeenCount + 1, count, "GameObjectBroadcast was not handled!");
729
+ lastSeenCount = count;
730
+ };
731
+ Run(
732
+ () =>
733
+ new[]
734
+ {
735
+ token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(
736
+ test,
737
+ PostProcessor
738
+ ),
739
+ token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
740
+ test,
741
+ _ => ++count
742
+ ),
743
+ },
744
+ () => message.EmitGameObjectBroadcast(test),
745
+ () =>
746
+ {
747
+ Assert.AreEqual(
748
+ lastSeenCount,
749
+ count,
750
+ "GameObjectBroadcast PostProcessor was not run!"
751
+ );
752
+ finalCount = count;
753
+ },
754
+ () =>
755
+ {
756
+ Assert.AreEqual(finalCount, lastSeenCount);
757
+ Assert.AreEqual(finalCount, count);
758
+ },
759
+ token,
760
+ synchronizeDeregistrations: true
761
+ );
762
+
763
+ ResetCount();
764
+ assertion = () =>
765
+ {
766
+ ++count;
767
+ };
768
+ Run(
769
+ () =>
770
+ new[]
771
+ {
772
+ token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(
773
+ test,
774
+ PostProcessor
775
+ ),
776
+ token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(
777
+ test,
778
+ PostProcessor
779
+ ),
780
+ },
781
+ () => message.EmitGameObjectBroadcast(test),
782
+ () =>
783
+ Assert.AreEqual(
784
+ ++lastSeenCount,
785
+ count,
786
+ "GameObjectBroadcast PostProcessor was ran twice!"
787
+ ),
788
+ () =>
789
+ {
790
+ Assert.AreEqual(
791
+ lastSeenCount,
792
+ count,
793
+ "GameObjectPostProcessor ran without any receivers subscribed!"
794
+ );
795
+ },
796
+ token,
797
+ synchronizeDeregistrations: true
798
+ );
799
+
800
+ ResetCount();
801
+ assertion = () =>
802
+ {
803
+ Assert.Fail("Should never be called, we're emitting the wrong thing");
804
+ };
805
+ Run(
806
+ () =>
807
+ new[]
808
+ {
809
+ token.RegisterGameObjectBroadcastPostProcessor<SimpleBroadcastMessage>(
810
+ test,
811
+ PostProcessor
812
+ ),
813
+ },
814
+ () => message.EmitComponentBroadcast(component),
815
+ () =>
816
+ {
817
+ Assert.AreEqual(0, count);
818
+ Assert.AreEqual(0, lastSeenCount);
819
+ },
820
+ () =>
821
+ {
822
+ Assert.AreEqual(0, count);
823
+ Assert.AreEqual(0, lastSeenCount);
824
+ },
825
+ token
826
+ );
827
+
828
+ yield break;
829
+ }
830
+
831
+ [UnityTest]
832
+ public IEnumerator GameObjectBroadcastWithoutSource()
833
+ {
834
+ GameObject test = new(
835
+ nameof(GameObjectBroadcastWithoutSource),
836
+ typeof(EmptyMessageAwareComponent)
837
+ );
838
+ _spawned.Add(test);
839
+
840
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
841
+ MessageRegistrationToken token = GetToken(component);
842
+
843
+ int lastSeenCount = 0;
844
+ int count = 0;
845
+
846
+ int finalCount = 0;
847
+ void ResetCount()
848
+ {
849
+ lastSeenCount = 0;
850
+ count = 0;
851
+ finalCount = 0;
852
+ }
853
+
854
+ Action assertion;
855
+
856
+ void PostProcessor(ref InstanceId target, ref SimpleBroadcastMessage message)
857
+ {
858
+ assertion.Invoke();
859
+ }
860
+
861
+ count = 1;
862
+ assertion = () =>
863
+ {
864
+ Assert.AreEqual(lastSeenCount + 1, count);
865
+ };
866
+
867
+ SimpleBroadcastMessage message = new();
868
+ Run(
869
+ () =>
870
+ new[]
871
+ {
872
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
873
+ PostProcessor
874
+ ),
875
+ },
876
+ () => message.EmitGameObjectBroadcast(test),
877
+ () =>
878
+ {
879
+ lastSeenCount = count++;
880
+ finalCount = count;
881
+ },
882
+ () =>
883
+ {
884
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
885
+ Assert.AreEqual(finalCount, count);
886
+ },
887
+ token
888
+ );
889
+
890
+ ResetCount();
891
+ assertion = () =>
892
+ {
893
+ Assert.AreEqual(lastSeenCount + 1, count, "GameObjectBroadcast was not handled!");
894
+ lastSeenCount = count;
895
+ };
896
+ Run(
897
+ () =>
898
+ new[]
899
+ {
900
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
901
+ PostProcessor
902
+ ),
903
+ token.RegisterGameObjectBroadcast<SimpleBroadcastMessage>(
904
+ test,
905
+ _ => ++count
906
+ ),
907
+ },
908
+ () => message.EmitGameObjectBroadcast(test),
909
+ () =>
910
+ {
911
+ Assert.AreEqual(
912
+ lastSeenCount,
913
+ count,
914
+ "GameObjectBroadcast PostProcessor was not run!"
915
+ );
916
+ finalCount = count;
917
+ },
918
+ () =>
919
+ {
920
+ Assert.AreEqual(finalCount, lastSeenCount);
921
+ Assert.AreEqual(finalCount, count);
922
+ },
923
+ token,
924
+ synchronizeDeregistrations: true
925
+ );
926
+
927
+ ResetCount();
928
+ assertion = () =>
929
+ {
930
+ ++count;
931
+ };
932
+ Run(
933
+ () =>
934
+ new[]
935
+ {
936
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
937
+ PostProcessor
938
+ ),
939
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
940
+ PostProcessor
941
+ ),
942
+ },
943
+ () => message.EmitGameObjectBroadcast(test),
944
+ () =>
945
+ Assert.AreEqual(
946
+ ++lastSeenCount,
947
+ count,
948
+ "GameObjectBroadcast PostProcessor was ran twice!"
949
+ ),
950
+ () =>
951
+ {
952
+ Assert.AreEqual(
953
+ lastSeenCount,
954
+ count,
955
+ "GameObjectPostProcessor ran without any receivers subscribed!"
956
+ );
957
+ },
958
+ token,
959
+ synchronizeDeregistrations: true
960
+ );
961
+
962
+ yield break;
963
+ }
964
+
965
+ [UnityTest]
966
+ public IEnumerator ComponentBroadcast()
967
+ {
968
+ GameObject test = new(nameof(ComponentBroadcast), typeof(EmptyMessageAwareComponent));
969
+ _spawned.Add(test);
970
+
971
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
972
+ MessageRegistrationToken token = GetToken(component);
973
+
974
+ int lastSeenCount = 0;
975
+ int count = 0;
976
+
977
+ int finalCount = 0;
978
+ void ResetCount()
979
+ {
980
+ lastSeenCount = 0;
981
+ count = 0;
982
+ finalCount = 0;
983
+ }
984
+
985
+ Action assertion;
986
+
987
+ void PostProcessor(ref SimpleBroadcastMessage message)
988
+ {
989
+ assertion.Invoke();
990
+ }
991
+
992
+ count = 1;
993
+ assertion = () =>
994
+ {
995
+ Assert.AreEqual(lastSeenCount + 1, count);
996
+ };
997
+
998
+ SimpleBroadcastMessage message = new();
999
+ Run(
1000
+ () =>
1001
+ new[]
1002
+ {
1003
+ token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(
1004
+ component,
1005
+ PostProcessor
1006
+ ),
1007
+ },
1008
+ () => message.EmitComponentBroadcast(component),
1009
+ () =>
1010
+ {
1011
+ lastSeenCount = count++;
1012
+ finalCount = count;
1013
+ },
1014
+ () =>
1015
+ {
1016
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
1017
+ Assert.AreEqual(finalCount, count);
1018
+ },
1019
+ token
1020
+ );
1021
+
1022
+ ResetCount();
1023
+ assertion = () =>
1024
+ {
1025
+ Assert.AreEqual(lastSeenCount + 1, count);
1026
+ lastSeenCount = count;
1027
+ };
1028
+ Run(
1029
+ () =>
1030
+ new[]
1031
+ {
1032
+ token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(
1033
+ component,
1034
+ PostProcessor
1035
+ ),
1036
+ token.RegisterComponentBroadcast<SimpleBroadcastMessage>(
1037
+ component,
1038
+ _ => ++count
1039
+ ),
1040
+ },
1041
+ () => message.EmitComponentBroadcast(component),
1042
+ () =>
1043
+ {
1044
+ Assert.AreEqual(lastSeenCount, count);
1045
+ finalCount = count;
1046
+ },
1047
+ () =>
1048
+ {
1049
+ Assert.AreEqual(finalCount, lastSeenCount);
1050
+ Assert.AreEqual(finalCount, count);
1051
+ },
1052
+ token,
1053
+ synchronizeDeregistrations: true
1054
+ );
1055
+
1056
+ ResetCount();
1057
+ assertion = () =>
1058
+ {
1059
+ ++count;
1060
+ };
1061
+ Run(
1062
+ () =>
1063
+ new[]
1064
+ {
1065
+ token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(
1066
+ component,
1067
+ PostProcessor
1068
+ ),
1069
+ token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(
1070
+ component,
1071
+ PostProcessor
1072
+ ),
1073
+ },
1074
+ () => message.EmitComponentBroadcast(component),
1075
+ () => Assert.AreEqual(++lastSeenCount, count),
1076
+ () =>
1077
+ {
1078
+ Assert.AreEqual(lastSeenCount, count);
1079
+ },
1080
+ token,
1081
+ synchronizeDeregistrations: true
1082
+ );
1083
+
1084
+ ResetCount();
1085
+ assertion = () =>
1086
+ {
1087
+ Assert.Fail("Should never be called, we're emitting the wrong thing");
1088
+ };
1089
+ Run(
1090
+ () =>
1091
+ new[]
1092
+ {
1093
+ token.RegisterComponentBroadcastPostProcessor<SimpleBroadcastMessage>(
1094
+ component,
1095
+ PostProcessor
1096
+ ),
1097
+ },
1098
+ () => message.EmitGameObjectBroadcast(test),
1099
+ () =>
1100
+ {
1101
+ Assert.AreEqual(0, count);
1102
+ Assert.AreEqual(0, lastSeenCount);
1103
+ },
1104
+ () =>
1105
+ {
1106
+ Assert.AreEqual(0, count);
1107
+ Assert.AreEqual(0, lastSeenCount);
1108
+ },
1109
+ token
1110
+ );
1111
+
1112
+ yield break;
1113
+ }
1114
+
1115
+ [UnityTest]
1116
+ public IEnumerator ComponentBroadcastWithoutSource()
1117
+ {
1118
+ GameObject test = new(
1119
+ nameof(ComponentBroadcastWithoutSource),
1120
+ typeof(EmptyMessageAwareComponent)
1121
+ );
1122
+ _spawned.Add(test);
1123
+
1124
+ EmptyMessageAwareComponent component = test.GetComponent<EmptyMessageAwareComponent>();
1125
+ MessageRegistrationToken token = GetToken(component);
1126
+
1127
+ int lastSeenCount = 0;
1128
+ int count = 0;
1129
+
1130
+ int finalCount = 0;
1131
+ void ResetCount()
1132
+ {
1133
+ lastSeenCount = 0;
1134
+ count = 0;
1135
+ finalCount = 0;
1136
+ }
1137
+
1138
+ Action assertion;
1139
+
1140
+ void PostProcessor(ref InstanceId source, ref SimpleBroadcastMessage message)
1141
+ {
1142
+ assertion.Invoke();
1143
+ }
1144
+
1145
+ count = 1;
1146
+ assertion = () =>
1147
+ {
1148
+ Assert.AreEqual(lastSeenCount + 1, count);
1149
+ };
1150
+
1151
+ SimpleBroadcastMessage message = new();
1152
+ Run(
1153
+ () =>
1154
+ new[]
1155
+ {
1156
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
1157
+ PostProcessor
1158
+ ),
1159
+ },
1160
+ () => message.EmitComponentBroadcast(component),
1161
+ () =>
1162
+ {
1163
+ lastSeenCount = count++;
1164
+ finalCount = count;
1165
+ },
1166
+ () =>
1167
+ {
1168
+ Assert.AreEqual(finalCount - 1, lastSeenCount);
1169
+ Assert.AreEqual(finalCount, count);
1170
+ },
1171
+ token
1172
+ );
1173
+
1174
+ ResetCount();
1175
+ assertion = () =>
1176
+ {
1177
+ Assert.AreEqual(lastSeenCount + 1, count);
1178
+ lastSeenCount = count;
1179
+ };
1180
+ Run(
1181
+ () =>
1182
+ new[]
1183
+ {
1184
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
1185
+ PostProcessor
1186
+ ),
1187
+ token.RegisterComponentBroadcast<SimpleBroadcastMessage>(
1188
+ component,
1189
+ _ => ++count
1190
+ ),
1191
+ },
1192
+ () => message.EmitComponentBroadcast(component),
1193
+ () =>
1194
+ {
1195
+ Assert.AreEqual(lastSeenCount, count);
1196
+ finalCount = count;
1197
+ },
1198
+ () =>
1199
+ {
1200
+ Assert.AreEqual(finalCount, lastSeenCount);
1201
+ Assert.AreEqual(finalCount, count);
1202
+ },
1203
+ token,
1204
+ synchronizeDeregistrations: true
1205
+ );
1206
+
1207
+ ResetCount();
1208
+ assertion = () =>
1209
+ {
1210
+ ++count;
1211
+ };
1212
+ Run(
1213
+ () =>
1214
+ new[]
1215
+ {
1216
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
1217
+ PostProcessor
1218
+ ),
1219
+ token.RegisterBroadcastWithoutSourcePostProcessor<SimpleBroadcastMessage>(
1220
+ PostProcessor
1221
+ ),
1222
+ },
1223
+ () => message.EmitComponentBroadcast(component),
1224
+ () => Assert.AreEqual(++lastSeenCount, count),
1225
+ () =>
1226
+ {
1227
+ Assert.AreEqual(lastSeenCount, count);
1228
+ },
1229
+ token,
1230
+ synchronizeDeregistrations: true
1231
+ );
1232
+
1233
+ yield break;
1234
+ }
1235
+ }
1236
+ }