com.wallstop-studios.unity-helpers 2.0.0-rc60 → 2.0.0-rc62

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 (26) hide show
  1. package/Editor/AnimationCopier.cs +4 -11
  2. package/Editor/AnimationCreator.cs +5 -9
  3. package/Editor/AnimatorControllerCopier.cs +4 -10
  4. package/Editor/CustomEditors/MatchColliderToSpriteEditor.cs +1 -3
  5. package/Editor/FitTextureSizeWizard.cs +2 -2
  6. package/Editor/PrefabCheckWizard.cs +7 -10
  7. package/Editor/SpriteSettingsApplier.cs +27 -10
  8. package/Editor/TextureResizerWizard.cs +2 -7
  9. package/Editor/TextureSettingsApplier.cs +1 -1
  10. package/Editor/WallstopStudios.UnityHelpers.Editor.asmdef +1 -1
  11. package/Runtime/Core/Extension/ColorExtensions.cs +15 -0
  12. package/Runtime/Core/Extension/LoggingExtensions.cs +68 -121
  13. package/Runtime/Core/Helper/Helpers.cs +3 -3
  14. package/Runtime/Core/Helper/Logging/UnityLogTagFormatter.cs +489 -0
  15. package/Runtime/Core/Helper/Logging/UnityLogTagFormatter.cs.meta +3 -0
  16. package/Runtime/Core/Helper/Logging.meta +3 -0
  17. package/Runtime/Core/Helper/Partials/LogHelpers.cs +1 -1
  18. package/Runtime/Core/Helper/Partials/ObjectHelpers.cs +2 -6
  19. package/Runtime/Core/Helper/ReflectionHelpers.cs +149 -35
  20. package/Runtime/Core/Helper/SpriteHelpers.cs +2 -2
  21. package/Runtime/Utils/CircleLineRenderer.cs +3 -5
  22. package/Tests/Runtime/Extensions/LoggingExtensionTests.cs +718 -0
  23. package/Tests/Runtime/Extensions/LoggingExtensionTests.cs.meta +3 -0
  24. package/Tests/Runtime/Helper/WallMathTests.cs +1 -1
  25. package/Tests/Runtime/Random/RandomTestBase.cs +2 -2
  26. package/package.json +1 -1
package/Tests/Runtime/Extensions/LoggingExtensionTests.cs ADDED
@@ -0,0 +1,718 @@
1
+ namespace UnityHelpers.Tests.Extensions
2
+ {
3
+ using System;
4
+ using System.Collections.Generic;
5
+ using System.Linq;
6
+ using Core.Extension;
7
+ using Core.Helper;
8
+ using Core.Helper.Logging;
9
+ using NUnit.Framework;
10
+ using UnityEngine;
11
+
12
+ public sealed class LoggingExtensionTests
13
+ {
14
+ [Test]
15
+ public void Registration()
16
+ {
17
+ UnityLogTagFormatter formatter = new(createDefaultDecorators: false);
18
+ Assert.AreEqual(
19
+ 0,
20
+ formatter.Decorations.Count(),
21
+ $"Found an unexpected number of registered decorations {formatter.Decorations.ToJson()}"
22
+ );
23
+
24
+ bool added = formatter.AddDecoration("b", value => $"<b>{value}</b>", "Bold");
25
+ Assert.IsTrue(added);
26
+ string formatted = formatter.Log($"{"Hello":b}", pretty: false);
27
+ Assert.AreEqual("<b>Hello</b>", formatted);
28
+ Assert.That(Enumerables.Of("Bold"), Is.EqualTo(formatter.Decorations));
29
+
30
+ added = formatter.AddDecoration("b", value => $"<c>{value}</c>", "Bold");
31
+ Assert.IsFalse(added);
32
+ formatted = formatter.Log($"{"Hello":b}", pretty: false);
33
+ Assert.AreEqual("<b>Hello</b>", formatted);
34
+ Assert.That(Enumerables.Of("Bold"), Is.EqualTo(formatter.Decorations));
35
+
36
+ added = formatter.AddDecoration("c", value => $"<c>{value}</c>", "Bold");
37
+ Assert.IsFalse(added);
38
+ formatted = formatter.Log($"{"Hello":b}", pretty: false);
39
+ Assert.AreEqual("<b>Hello</b>", formatted);
40
+ Assert.That(Enumerables.Of("Bold"), Is.EqualTo(formatter.Decorations));
41
+
42
+ added = formatter.AddDecoration("c", value => $"<c>{value}</c>", "Bold1");
43
+ Assert.IsTrue(added);
44
+ formatted = formatter.Log($"{"Hello":b}", pretty: false);
45
+ Assert.AreEqual("<b>Hello</b>", formatted);
46
+ Assert.That(Enumerables.Of("Bold", "Bold1"), Is.EqualTo(formatter.Decorations));
47
+ formatted = formatter.Log($"{"Hello":c}", pretty: false);
48
+ Assert.AreEqual("<c>Hello</c>", formatted);
49
+ Assert.That(Enumerables.Of("Bold", "Bold1"), Is.EqualTo(formatter.Decorations));
50
+
51
+ added = formatter.AddDecoration("b", value => $"<c>{value}</c>", "Bold", force: true);
52
+ Assert.IsTrue(added);
53
+ Assert.That(Enumerables.Of("Bold", "Bold1"), Is.EqualTo(formatter.Decorations));
54
+ formatted = formatter.Log($"{"Hello":b}", pretty: false);
55
+ Assert.AreEqual("<c>Hello</c>", formatted);
56
+
57
+ bool removed = formatter.RemoveDecoration("Bold", out _);
58
+ Assert.IsTrue(removed);
59
+ Assert.That(Enumerables.Of("Bold1"), Is.EqualTo(formatter.Decorations));
60
+ formatted = formatter.Log($"{"Hello":b}", pretty: false);
61
+ Assert.AreEqual("Hello", formatted);
62
+ formatted = formatter.Log($"{"Hello":c}", pretty: false);
63
+ Assert.AreEqual("<c>Hello</c>", formatted);
64
+ }
65
+
66
+ [Test]
67
+ public void SimpleLogging()
68
+ {
69
+ GameObject go = new(nameof(SimpleLogging), typeof(SpriteRenderer));
70
+
71
+ int logCount = 0;
72
+ Exception exception = null;
73
+ Action<string> assertion = null;
74
+ Application.logMessageReceived += HandleMessageReceived;
75
+ try
76
+ {
77
+ int expectedLogCount = 0;
78
+ foreach (bool pretty in new[] { true, false })
79
+ {
80
+ assertion = message =>
81
+ {
82
+ if (pretty)
83
+ {
84
+ Assert.IsTrue(message.Contains(nameof(SimpleLogging)), message);
85
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
86
+ Assert.IsTrue(message.Contains("Hello, world!"), message);
87
+ }
88
+ else
89
+ {
90
+ Assert.AreEqual("Hello, world!", message);
91
+ }
92
+ };
93
+
94
+ go.Log($"Hello, world!", pretty: pretty);
95
+ Assert.AreEqual(++expectedLogCount, logCount);
96
+ Assert.IsNull(exception, exception?.ToString());
97
+
98
+ SpriteRenderer sr = go.GetComponent<SpriteRenderer>();
99
+
100
+ assertion = message =>
101
+ {
102
+ if (pretty)
103
+ {
104
+ Assert.IsTrue(message.Contains(nameof(SimpleLogging)), message);
105
+ Assert.IsTrue(message.Contains(nameof(SpriteRenderer)), message);
106
+ Assert.IsTrue(message.Contains("Hello, world!"), message);
107
+ }
108
+ else
109
+ {
110
+ Assert.AreEqual("Hello, world!", message);
111
+ }
112
+ };
113
+
114
+ sr.Log($"Hello, world!", pretty: pretty);
115
+
116
+ Assert.AreEqual(++expectedLogCount, logCount);
117
+ Assert.IsNull(exception, exception?.ToString());
118
+ }
119
+ }
120
+ finally
121
+ {
122
+ Application.logMessageReceived -= HandleMessageReceived;
123
+ }
124
+
125
+ return;
126
+
127
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
128
+ {
129
+ ++logCount;
130
+ try
131
+ {
132
+ assertion?.Invoke(message);
133
+ }
134
+ catch (Exception e)
135
+ {
136
+ exception = e;
137
+ throw;
138
+ }
139
+ }
140
+ }
141
+
142
+ [Test]
143
+ public void ColorLogging()
144
+ {
145
+ GameObject go = new(nameof(ColorLogging), typeof(SpriteRenderer));
146
+
147
+ int logCount = 0;
148
+ Exception exception = null;
149
+ Action<string> assertion = null;
150
+ Application.logMessageReceived += HandleMessageReceived;
151
+
152
+ try
153
+ {
154
+ int expectedLogCount = 0;
155
+ foreach (bool pretty in new[] { true, false })
156
+ {
157
+ assertion = message =>
158
+ {
159
+ if (pretty)
160
+ {
161
+ Assert.IsTrue(message.Contains(nameof(ColorLogging)), message);
162
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
163
+ Assert.IsTrue(
164
+ message.Contains("Hello <color=#FF0000FF>world</color>"),
165
+ message
166
+ );
167
+ }
168
+ else
169
+ {
170
+ Assert.AreEqual("Hello <color=#FF0000FF>world</color>", message);
171
+ }
172
+ };
173
+ go.Log($"Hello {"world":#red}", pretty: pretty);
174
+ Assert.AreEqual(++expectedLogCount, logCount);
175
+ Assert.IsNull(exception, exception?.ToString());
176
+
177
+ assertion = message =>
178
+ {
179
+ if (pretty)
180
+ {
181
+ Assert.IsTrue(message.Contains(nameof(ColorLogging)), message);
182
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
183
+ Assert.IsTrue(
184
+ message.Contains("Hello <color=#00FF00FF>world</color>"),
185
+ message
186
+ );
187
+ }
188
+ else
189
+ {
190
+ Assert.AreEqual("Hello <color=#00FF00FF>world</color>", message);
191
+ }
192
+ };
193
+ go.Log($"Hello {"world":#green}", pretty: pretty);
194
+ Assert.AreEqual(++expectedLogCount, logCount);
195
+ Assert.IsNull(exception, exception?.ToString());
196
+
197
+ assertion = message =>
198
+ {
199
+ if (pretty)
200
+ {
201
+ Assert.IsTrue(message.Contains(nameof(ColorLogging)), message);
202
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
203
+ Assert.IsTrue(
204
+ message.Contains("Hello <color=#FFAABB>world</color>"),
205
+ message
206
+ );
207
+ }
208
+ else
209
+ {
210
+ Assert.AreEqual("Hello <color=#FFAABB>world</color>", message);
211
+ }
212
+ };
213
+ go.Log($"Hello {"world":#FFAABB}", pretty: pretty);
214
+ Assert.AreEqual(++expectedLogCount, logCount);
215
+ Assert.IsNull(exception, exception?.ToString());
216
+ }
217
+ }
218
+ finally
219
+ {
220
+ Application.logMessageReceived -= HandleMessageReceived;
221
+ }
222
+
223
+ return;
224
+
225
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
226
+ {
227
+ ++logCount;
228
+ try
229
+ {
230
+ assertion?.Invoke(message);
231
+ }
232
+ catch (Exception e)
233
+ {
234
+ exception = e;
235
+ throw;
236
+ }
237
+ }
238
+ }
239
+
240
+ [Test]
241
+ public void BoldLogging()
242
+ {
243
+ GameObject go = new(nameof(BoldLogging), typeof(SpriteRenderer));
244
+
245
+ int logCount = 0;
246
+ Exception exception = null;
247
+ Action<string> assertion = null;
248
+ Application.logMessageReceived += HandleMessageReceived;
249
+
250
+ try
251
+ {
252
+ int expectedLogCount = 0;
253
+ foreach (bool pretty in new[] { true, false })
254
+ {
255
+ assertion = message =>
256
+ {
257
+ if (pretty)
258
+ {
259
+ Assert.IsTrue(message.Contains(nameof(BoldLogging)), message);
260
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
261
+ Assert.IsTrue(message.Contains("Hello <b>world</b>"), message);
262
+ }
263
+ else
264
+ {
265
+ Assert.AreEqual("Hello <b>world</b>", message);
266
+ }
267
+ };
268
+ go.Log($"Hello {"world":b}", pretty: pretty);
269
+ Assert.AreEqual(++expectedLogCount, logCount);
270
+ Assert.IsNull(exception, exception?.ToString());
271
+
272
+ go.Log($"Hello {"world":bold}", pretty: pretty);
273
+ Assert.AreEqual(++expectedLogCount, logCount);
274
+ Assert.IsNull(exception, exception?.ToString());
275
+
276
+ go.Log($"Hello {"world":!}", pretty: pretty);
277
+ Assert.AreEqual(++expectedLogCount, logCount);
278
+ Assert.IsNull(exception, exception?.ToString());
279
+ }
280
+ }
281
+ finally
282
+ {
283
+ Application.logMessageReceived -= HandleMessageReceived;
284
+ }
285
+
286
+ return;
287
+
288
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
289
+ {
290
+ ++logCount;
291
+ try
292
+ {
293
+ assertion?.Invoke(message);
294
+ }
295
+ catch (Exception e)
296
+ {
297
+ exception = e;
298
+ throw;
299
+ }
300
+ }
301
+ }
302
+
303
+ [Test]
304
+ public void JsonLogging()
305
+ {
306
+ GameObject go = new(nameof(JsonLogging), typeof(SpriteRenderer));
307
+
308
+ int logCount = 0;
309
+ Exception exception = null;
310
+ Action<string> assertion = null;
311
+ Application.logMessageReceived += HandleMessageReceived;
312
+
313
+ try
314
+ {
315
+ int expectedLogCount = 0;
316
+ foreach (bool pretty in new[] { true, false })
317
+ {
318
+ assertion = message =>
319
+ {
320
+ if (pretty)
321
+ {
322
+ Assert.IsTrue(message.Contains(nameof(JsonLogging)), message);
323
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
324
+ Assert.IsTrue(message.Contains("Hello [\"a\",\"b\",\"c\"]"), message);
325
+ }
326
+ else
327
+ {
328
+ Assert.AreEqual("Hello [\"a\",\"b\",\"c\"]", message);
329
+ }
330
+ };
331
+
332
+ go.Log($"Hello {new List<string> { "a", "b", "c" }:json}", pretty: pretty);
333
+ Assert.AreEqual(++expectedLogCount, logCount);
334
+ Assert.IsNull(exception, exception?.ToString());
335
+
336
+ assertion = message =>
337
+ {
338
+ if (pretty)
339
+ {
340
+ Assert.IsTrue(message.Contains(nameof(JsonLogging)), message);
341
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
342
+ Assert.IsTrue(message.Contains("Hello {}"), message);
343
+ }
344
+ else
345
+ {
346
+ Assert.AreEqual("Hello {}", message);
347
+ }
348
+ };
349
+ go.Log($"Hello {null:json}", pretty: pretty);
350
+ Assert.AreEqual(++expectedLogCount, logCount);
351
+ Assert.IsNull(exception, exception?.ToString());
352
+
353
+ assertion = message =>
354
+ {
355
+ if (pretty)
356
+ {
357
+ Assert.IsTrue(message.Contains(nameof(JsonLogging)), message);
358
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
359
+ Assert.IsTrue(message.Contains("Hello [1,2,3,4]"), message);
360
+ }
361
+ else
362
+ {
363
+ Assert.AreEqual("Hello [1,2,3,4]", message);
364
+ }
365
+ };
366
+ go.Log($"Hello {new[] { 1, 2, 3, 4 }:json}", pretty: pretty);
367
+ Assert.AreEqual(++expectedLogCount, logCount);
368
+ Assert.IsNull(exception, exception?.ToString());
369
+
370
+ assertion = message =>
371
+ {
372
+ if (pretty)
373
+ {
374
+ Assert.IsTrue(message.Contains(nameof(JsonLogging)), message);
375
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
376
+ Assert.IsTrue(message.Contains("Hello {\"key\":\"value\"}"), message);
377
+ }
378
+ else
379
+ {
380
+ Assert.AreEqual("Hello {\"key\":\"value\"}", message);
381
+ }
382
+ };
383
+ go.Log(
384
+ $"Hello {new Dictionary<string, string> { ["key"] = "value" }:json}",
385
+ pretty: pretty
386
+ );
387
+ Assert.AreEqual(++expectedLogCount, logCount);
388
+ Assert.IsNull(exception, exception?.ToString());
389
+ }
390
+ }
391
+ finally
392
+ {
393
+ Application.logMessageReceived -= HandleMessageReceived;
394
+ }
395
+
396
+ return;
397
+
398
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
399
+ {
400
+ ++logCount;
401
+ try
402
+ {
403
+ assertion?.Invoke(message);
404
+ }
405
+ catch (Exception e)
406
+ {
407
+ exception = e;
408
+ throw;
409
+ }
410
+ }
411
+ }
412
+
413
+ [Test]
414
+ public void SizeLogging()
415
+ {
416
+ GameObject go = new(nameof(SizeLogging), typeof(SpriteRenderer));
417
+
418
+ int logCount = 0;
419
+ Exception exception = null;
420
+ Action<string> assertion = null;
421
+ Application.logMessageReceived += HandleMessageReceived;
422
+
423
+ try
424
+ {
425
+ int expectedLogCount = 0;
426
+ foreach (bool pretty in new[] { true, false })
427
+ {
428
+ assertion = message =>
429
+ {
430
+ if (pretty)
431
+ {
432
+ Assert.IsTrue(message.Contains(nameof(SizeLogging)), message);
433
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
434
+ Assert.IsTrue(message.Contains("Hello <size=40>world</size>"), message);
435
+ }
436
+ else
437
+ {
438
+ Assert.AreEqual("Hello <size=40>world</size>", message);
439
+ }
440
+ };
441
+ go.Log($"Hello {"world":40}", pretty: pretty);
442
+ Assert.AreEqual(++expectedLogCount, logCount);
443
+ Assert.IsNull(exception, exception?.ToString());
444
+
445
+ go.Log($"Hello {"world":size=40}", pretty: pretty);
446
+ Assert.AreEqual(++expectedLogCount, logCount);
447
+ Assert.IsNull(exception, exception?.ToString());
448
+ }
449
+ }
450
+ finally
451
+ {
452
+ Application.logMessageReceived -= HandleMessageReceived;
453
+ }
454
+
455
+ return;
456
+
457
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
458
+ {
459
+ ++logCount;
460
+ try
461
+ {
462
+ assertion?.Invoke(message);
463
+ }
464
+ catch (Exception e)
465
+ {
466
+ exception = e;
467
+ throw;
468
+ }
469
+ }
470
+ }
471
+
472
+ [Test]
473
+ public void DateTimeNormalFormatTests()
474
+ {
475
+ GameObject go = new(nameof(DateTimeNormalFormatTests), typeof(SpriteRenderer));
476
+ int logCount = 0;
477
+ Exception exception = null;
478
+ Action<string> assertion = null;
479
+ Application.logMessageReceived += HandleMessageReceived;
480
+ try
481
+ {
482
+ int expectedLogCount = 0;
483
+ DateTime now = DateTime.UtcNow;
484
+ foreach (bool pretty in new[] { true, false })
485
+ {
486
+ assertion = message =>
487
+ {
488
+ if (pretty)
489
+ {
490
+ Assert.IsTrue(
491
+ message.Contains(nameof(DateTimeNormalFormatTests)),
492
+ message
493
+ );
494
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
495
+ Assert.IsTrue(message.Contains($"Hello {now:O}"), message);
496
+ }
497
+ else
498
+ {
499
+ Assert.AreEqual($"Hello {now:O}", message);
500
+ }
501
+ };
502
+
503
+ go.Log($"Hello {now:O}", pretty: pretty);
504
+ Assert.AreEqual(++expectedLogCount, logCount);
505
+ Assert.IsNull(exception, exception?.ToString());
506
+
507
+ assertion = message =>
508
+ {
509
+ if (pretty)
510
+ {
511
+ Assert.IsTrue(
512
+ message.Contains(nameof(DateTimeNormalFormatTests)),
513
+ message
514
+ );
515
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
516
+ Assert.IsTrue(
517
+ message.Contains($"Hello <size=40>{now}</size>"),
518
+ message
519
+ );
520
+ }
521
+ else
522
+ {
523
+ Assert.AreEqual($"Hello <size=40>{now}</size>", message);
524
+ }
525
+ };
526
+
527
+ go.Log($"Hello {now:40}", pretty: pretty);
528
+ Assert.AreEqual(++expectedLogCount, logCount);
529
+ Assert.IsNull(exception, exception?.ToString());
530
+ }
531
+ }
532
+ finally
533
+ {
534
+ Application.logMessageReceived -= HandleMessageReceived;
535
+ }
536
+
537
+ return;
538
+
539
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
540
+ {
541
+ ++logCount;
542
+ try
543
+ {
544
+ assertion?.Invoke(message);
545
+ }
546
+ catch (Exception e)
547
+ {
548
+ exception = e;
549
+ throw;
550
+ }
551
+ }
552
+ }
553
+
554
+ [Test]
555
+ public void StackedTags()
556
+ {
557
+ GameObject go = new(nameof(StackedTags), typeof(SpriteRenderer));
558
+ int logCount = 0;
559
+ Exception exception = null;
560
+ Action<string> assertion = null;
561
+ Application.logMessageReceived += HandleMessageReceived;
562
+
563
+ try
564
+ {
565
+ int expectedLogCount = 0;
566
+ foreach (bool pretty in new[] { true, false })
567
+ {
568
+ assertion = message =>
569
+ {
570
+ if (pretty)
571
+ {
572
+ Assert.IsTrue(message.Contains(nameof(StackedTags)), message);
573
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
574
+ Assert.IsTrue(message.Contains("Hello <b>[1,2,3]</b>"), message);
575
+ }
576
+ else
577
+ {
578
+ Assert.AreEqual("Hello <b>[1,2,3]</b>", message);
579
+ }
580
+ };
581
+
582
+ go.Log($"Hello {new List<int> { 1, 2, 3 }:json,b}", pretty: pretty);
583
+ Assert.AreEqual(++expectedLogCount, logCount);
584
+ Assert.IsNull(exception, exception?.ToString());
585
+
586
+ assertion = message =>
587
+ {
588
+ if (pretty)
589
+ {
590
+ Assert.IsTrue(message.Contains(nameof(StackedTags)), message);
591
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
592
+ Assert.IsTrue(
593
+ message.Contains("Hello <color=#FF0000FF><b>[1,2,3]</b></color>"),
594
+ message
595
+ );
596
+ }
597
+ else
598
+ {
599
+ Assert.AreEqual(
600
+ "Hello <color=#FF0000FF><b>[1,2,3]</b></color>",
601
+ message
602
+ );
603
+ }
604
+ };
605
+
606
+ go.Log($"Hello {new List<int> { 1, 2, 3 }:json,b,color=red}", pretty: pretty);
607
+ Assert.AreEqual(++expectedLogCount, logCount);
608
+ Assert.IsNull(exception, exception?.ToString());
609
+ }
610
+ }
611
+ finally
612
+ {
613
+ Application.logMessageReceived -= HandleMessageReceived;
614
+ }
615
+
616
+ return;
617
+
618
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
619
+ {
620
+ ++logCount;
621
+ try
622
+ {
623
+ assertion?.Invoke(message);
624
+ }
625
+ catch (Exception e)
626
+ {
627
+ exception = e;
628
+ throw;
629
+ }
630
+ }
631
+ }
632
+
633
+ [Test]
634
+ public void TagsDeduplicate()
635
+ {
636
+ GameObject go = new(nameof(TagsDeduplicate), typeof(SpriteRenderer));
637
+ int logCount = 0;
638
+ Exception exception = null;
639
+ Action<string> assertion = null;
640
+ Application.logMessageReceived += HandleMessageReceived;
641
+
642
+ try
643
+ {
644
+ int expectedLogCount = 0;
645
+ foreach (bool pretty in new[] { true, false })
646
+ {
647
+ assertion = message =>
648
+ {
649
+ if (pretty)
650
+ {
651
+ Assert.IsTrue(message.Contains(nameof(TagsDeduplicate)), message);
652
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
653
+ Assert.IsTrue(message.Contains("Hello <b>[1,2,3]</b>"), message);
654
+ }
655
+ else
656
+ {
657
+ Assert.AreEqual("Hello <b>[1,2,3]</b>", message);
658
+ }
659
+ };
660
+
661
+ go.Log(
662
+ $"Hello {new List<int> { 1, 2, 3 }:json,b,bold,!,bold,b,!,b,bold}",
663
+ pretty: pretty
664
+ );
665
+ Assert.AreEqual(++expectedLogCount, logCount);
666
+ Assert.IsNull(exception, exception?.ToString());
667
+
668
+ assertion = message =>
669
+ {
670
+ if (pretty)
671
+ {
672
+ Assert.IsTrue(message.Contains(nameof(TagsDeduplicate)), message);
673
+ Assert.IsTrue(message.Contains(nameof(GameObject)), message);
674
+ Assert.IsTrue(
675
+ message.Contains("Hello <color=#FF0000FF><b>[1,2,3]</b></color>"),
676
+ message
677
+ );
678
+ }
679
+ else
680
+ {
681
+ Assert.AreEqual(
682
+ "Hello <color=#FF0000FF><b>[1,2,3]</b></color>",
683
+ message
684
+ );
685
+ }
686
+ };
687
+
688
+ go.Log(
689
+ $"Hello {new List<int> { 1, 2, 3 }:json,b,!,color=red,b,b,b,b,b,b,b}",
690
+ pretty: pretty
691
+ );
692
+ Assert.AreEqual(++expectedLogCount, logCount);
693
+ Assert.IsNull(exception, exception?.ToString());
694
+ }
695
+ }
696
+ finally
697
+ {
698
+ Application.logMessageReceived -= HandleMessageReceived;
699
+ }
700
+
701
+ return;
702
+
703
+ void HandleMessageReceived(string message, string stackTrace, LogType type)
704
+ {
705
+ ++logCount;
706
+ try
707
+ {
708
+ assertion?.Invoke(message);
709
+ }
710
+ catch (Exception e)
711
+ {
712
+ exception = e;
713
+ throw;
714
+ }
715
+ }
716
+ }
717
+ }
718
+ }