< Summary

Class:AvatarShape_Tests.AnimatorLegacyShould
Assembly:AvatarShapeTests
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Components/Avatar/Tests/AvatarRendererShould.cs
Covered lines:0
Uncovered lines:24
Coverable lines:24
Total lines:343
Line coverage:0% (0 of 24)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SetUp()0%20400%
NotTriggerExpressionWithSameTimestamp()0%12300%
TriggerExpressionWithSameTimestamp()0%12300%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/Components/Avatar/Tests/AvatarRendererShould.cs

#LineLine coverage
 1using System;
 2using DCL;
 3using NUnit.Framework;
 4using System.Collections;
 5using System.Collections.Generic;
 6using System.Linq;
 7using UnityEngine;
 8using UnityEngine.TestTools;
 9
 10namespace AvatarShape_Tests
 11{
 12    public class AvatarRendererShould : IntegrationTestSuite_Legacy
 13    {
 14        private const string SUNGLASSES_ID = "dcl://base-avatars/black_sun_glasses";
 15        private const string BLUE_BANDANA_ID = "dcl://base-avatars/blue_bandana";
 16
 17        private AvatarModel avatarModel;
 18        private BaseDictionary<string, WearableItem> catalog;
 19        private AvatarRenderer avatarRenderer;
 20
 21        [UnitySetUp]
 22        protected override IEnumerator SetUp()
 23        {
 24            yield return base.SetUp();
 25
 26            avatarModel = new AvatarModel()
 27            {
 28                name = " test",
 29                hairColor = Color.white,
 30                eyeColor = Color.white,
 31                skinColor = Color.white,
 32                bodyShape = WearableLiterals.BodyShapes.FEMALE,
 33                wearables = new List<string>()
 34                    { }
 35            };
 36            catalog = AvatarAssetsTestHelpers.CreateTestCatalogLocal();
 37
 38            var avatarShape = AvatarShapeTestHelpers.CreateAvatarShape(scene, avatarModel);
 39            yield return new DCL.WaitUntil(() => avatarShape.everythingIsLoaded, 20);
 40
 41            avatarRenderer = avatarShape.avatarRenderer;
 42        }
 43
 44        [UnityTest]
 45        [Category("Explicit")]
 46        [Explicit("This test depends on the time defined in CatalogController.REQUESTS_TIME_OUT, so it can make the test
 47        public IEnumerator FailGracefullyWhenIdsCannotBeResolved()
 48        {
 49            var wearablePromise1 = CatalogController.RequestWearable("Invalid_id");
 50            var wearablePromise2 = CatalogController.RequestWearable("Scioli_right_arm");
 51            var wearablePromise3 = CatalogController.RequestWearable("Peron_hands");
 52
 53            yield return wearablePromise1;
 54            Assert.AreEqual("The request for the wearable 'Invalid_id' has exceed the set timeout!", wearablePromise1.er
 55
 56            yield return wearablePromise2;
 57            Assert.AreEqual("The request for the wearable 'Scioli_right_arm' has exceed the set timeout!", wearablePromi
 58
 59            yield return wearablePromise3;
 60            Assert.AreEqual("The request for the wearable 'Peron_hands' has exceed the set timeout!", wearablePromise3.e
 61        }
 62
 63        [UnityTest]
 64        [Category("Explicit")]
 65        [Explicit("Test too slow")]
 66        public IEnumerator ProcessVisibilityTrueWhenSetBeforeLoading()
 67        {
 68            //Clean hides/replaces to avoid interferences
 69            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 70            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 71
 72            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 73            avatarRenderer.SetVisibility(true);
 74
 75            bool ready = false;
 76            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 77            yield return new DCL.WaitUntil(() => ready);
 78
 79            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => x.enabled
 80        }
 81
 82        [UnityTest]
 83        [Category("Explicit")]
 84        [Explicit("Test too slow")]
 85        public IEnumerator ProcessVisibilityFalseWhenSetBeforeLoading()
 86        {
 87            //Clean hides/replaces to avoid interferences
 88            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 89            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 90
 91            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 92            avatarRenderer.SetVisibility(false);
 93
 94            bool ready = false;
 95            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 96            yield return new DCL.WaitUntil(() => ready);
 97
 98            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => !x.enable
 99        }
 100
 101        [UnityTest]
 102        [Category("Explicit")]
 103        [Explicit("Test too slow")]
 104        public IEnumerator ProcessVisibilityTrueWhenSetWhileLoading()
 105        {
 106            //Clean hides/replaces to avoid interferences
 107            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 108            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 109
 110            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 111
 112            bool ready = false;
 113            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 114            avatarRenderer.SetVisibility(true);
 115            yield return new DCL.WaitUntil(() => ready);
 116
 117            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => x.enabled
 118        }
 119
 120        [UnityTest]
 121        [Category("Explicit")]
 122        [Explicit("Test too slow")]
 123        public IEnumerator ProcessVisibilityFalseWhenSetWhileLoading()
 124        {
 125            //Clean hides/replaces to avoid interferences
 126            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 127            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 128
 129            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 130
 131            bool ready = false;
 132            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 133            avatarRenderer.SetVisibility(false);
 134            yield return new DCL.WaitUntil(() => ready);
 135
 136            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => !x.enable
 137        }
 138
 139        [UnityTest]
 140        [Category("Explicit")]
 141        [Explicit("Test too slow")]
 142        public IEnumerator ProcessVisibilityTrueWhenSetAfterLoading()
 143        {
 144            //Clean hides/replaces to avoid interferences
 145            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 146            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 147
 148            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 149
 150            bool ready = false;
 151            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 152            yield return new DCL.WaitUntil(() => ready);
 153            avatarRenderer.SetVisibility(true);
 154
 155            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => x.enabled
 156        }
 157
 158        [UnityTest]
 159        [Category("Explicit")]
 160        [Explicit("Test too slow")]
 161        public IEnumerator ProcessVisibilityFalseWhenSetAfterLoading()
 162        {
 163            //Clean hides/replaces to avoid interferences
 164            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 165            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 166
 167            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 168
 169            bool ready = false;
 170            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 171            yield return new DCL.WaitUntil(() => ready);
 172            avatarRenderer.SetVisibility(false);
 173
 174            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => !x.enable
 175        }
 176
 177        [UnityTest]
 178        [Category("Explicit")]
 179        [Explicit("Test too slow")]
 180        public IEnumerator ProcessHideListProperly_HeadHidden()
 181        {
 182            //Clean hides/replaces to avoid interferences
 183            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 184            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 185            catalog.Get(SUNGLASSES_ID).data.hides = new [] { WearableLiterals.Misc.HEAD };
 186
 187            avatarModel.wearables = new List<string>() { SUNGLASSES_ID };
 188
 189            bool ready = false;
 190            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 191            yield return new DCL.WaitUntil(() => ready);
 192
 193            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).headRenderer.enabled);
 194            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyebrowsRenderer.enabled);
 195            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyesRenderer.enabled);
 196            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).mouthRenderer.enabled);
 197        }
 198
 199        [UnityTest]
 200        [Category("Explicit")]
 201        [Explicit("Test too slow")]
 202        public IEnumerator ProcessHideListProperly_HeadShowing()
 203        {
 204            //Clean hides/replaces to avoid interferences
 205            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 206            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 207
 208            avatarModel.wearables = new List<string>() { SUNGLASSES_ID };
 209
 210            bool ready = false;
 211            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 212            yield return new DCL.WaitUntil(() => ready);
 213
 214            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).headRenderer.enabled);
 215            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyebrowsRenderer.enabled);
 216            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyesRenderer.enabled);
 217            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).mouthRenderer.enabled);
 218        }
 219
 220        [UnityTest]
 221        [Category("Explicit")]
 222        [Explicit("Test too slow")]
 223        [TestCase(null, ExpectedResult = null)]
 224        [TestCase("wave", ExpectedResult = null)]
 225        public IEnumerator ProcessExpression(string expressionId)
 226        {
 227            var animator = avatarRenderer.animator;
 228            var timestamp = DateTime.UtcNow.Ticks;
 229
 230            avatarModel.expressionTriggerId = expressionId;
 231            avatarModel.expressionTriggerTimestamp = timestamp;
 232
 233            bool ready = false;
 234            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 235            yield return new DCL.WaitUntil(() => ready);
 236
 237            Assert.AreEqual(animator.blackboard.expressionTriggerId, expressionId);
 238            Assert.AreEqual(animator.blackboard.expressionTriggerTimestamp, timestamp);
 239        }
 240
 241        [UnityTest]
 242        [Category("Explicit")]
 243        [Explicit("Test too slow")]
 244        public IEnumerator ChangeWearablesRepresentationWhenBodyShapeChanges()
 245        {
 246            string wearableId = "dcl://base-avatars/MultipleRepresentations";
 247            avatarModel.wearables = new List<string> { wearableId };
 248            avatarModel.bodyShape = WearableLiterals.BodyShapes.MALE;
 249
 250            bool ready = false;
 251            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 252            yield return new DCL.WaitUntil(() => ready);
 253
 254            var wearableController = avatarRenderer.wearableControllers.Values.FirstOrDefault(x => x.id == wearableId);
 255            Assert.NotNull(wearableController);
 256            Assert.AreEqual("M_Feet_Espadrilles.glb" , wearableController.lastMainFileLoaded);
 257
 258            avatarModel.bodyShape = WearableLiterals.BodyShapes.FEMALE;
 259            ready = false;
 260            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 261            yield return new DCL.WaitUntil(() => ready);
 262
 263            wearableController = avatarRenderer.wearableControllers.Values.FirstOrDefault(x => x.id == wearableId);
 264            Assert.NotNull(wearableController);
 265            Assert.AreEqual("Feet_XmasSockets.glb" , wearableController.lastMainFileLoaded);
 266        }
 267
 268        private void CleanWearableHidesAndReplaces(string id)
 269        {
 270            catalog.Get(id).data.hides = new string[] { };
 271            catalog.Get(id).data.replaces = new string[] { };
 272            foreach (WearableItem.Representation representation in catalog.Get(id).data.representations)
 273            {
 274                representation.overrideHides = new string[] { };
 275                representation.overrideReplaces = new string[] { };
 276            }
 277        }
 278    }
 279
 280    public class AnimatorLegacyShould : IntegrationTestSuite_Legacy
 281    {
 282        private AvatarModel avatarModel;
 283        private AvatarRenderer avatarRenderer;
 284        private AvatarAnimatorLegacy animator;
 285
 286        [UnitySetUp]
 287        protected override IEnumerator SetUp()
 288        {
 0289            yield return base.SetUp();
 290
 0291            avatarModel = new AvatarModel()
 292            {
 293                name = " test",
 294                hairColor = Color.white,
 295                eyeColor = Color.white,
 296                skinColor = Color.white,
 297                bodyShape = WearableLiterals.BodyShapes.FEMALE,
 298                wearables = new List<string>()
 299                    { }
 300            };
 301
 0302            AvatarAssetsTestHelpers.CreateTestCatalogLocal();
 303
 0304            var avatarShape = AvatarShapeTestHelpers.CreateAvatarShape(scene, avatarModel);
 0305            yield return new DCL.WaitUntil(() => avatarShape.everythingIsLoaded, 20);
 306
 0307            avatarRenderer = avatarShape.avatarRenderer;
 0308            animator = avatarRenderer.animator;
 0309        }
 310
 311        [UnityTest]
 312        [Category("Explicit")]
 313        [Explicit("Test too slow")]
 314        public IEnumerator NotTriggerExpressionWithSameTimestamp()
 315        {
 0316            avatarModel.expressionTriggerId = "wave";
 0317            avatarModel.expressionTriggerTimestamp = 1;
 0318            animator.blackboard.expressionTriggerTimestamp = 1;
 319
 0320            bool ready = false;
 0321            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0322            yield return new DCL.WaitUntil(() => ready);
 323
 0324            Assert.True(animator.currentState != animator.State_Expression);
 0325        }
 326
 327        [UnityTest]
 328        [Category("Explicit")]
 329        [Explicit("Test too slow")]
 330        public IEnumerator TriggerExpressionWithSameTimestamp()
 331        {
 0332            avatarModel.expressionTriggerId = "wave";
 0333            avatarModel.expressionTriggerTimestamp = DateTime.UtcNow.Ticks;
 0334            animator.blackboard.expressionTriggerTimestamp = -1;
 335
 0336            bool ready = false;
 0337            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0338            yield return new DCL.WaitUntil(() => ready);
 339
 0340            Assert.True(animator.currentState == animator.State_Expression);
 0341        }
 342    }
 343}
Generated by: ReportGenerator 4.8.9.0
07/13/2021 - 19:40:13
GitHub | www.palmmedia.de

Methods/Properties

SetUp()
NotTriggerExpressionWithSameTimestamp()
TriggerExpressionWithSameTimestamp()