< Summary

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

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SetUp()0%20400%
FailGracefullyWhenIdsCannotBeResolved()0%30500%
ProcessVisibilityTrueWhenSetBeforeLoading()0%20400%
ProcessVisibilityFalseWhenSetBeforeLoading()0%20400%
ProcessVisibilityTrueWhenSetWhileLoading()0%20400%
ProcessVisibilityFalseWhenSetWhileLoading()0%20400%
ProcessVisibilityTrueWhenSetAfterLoading()0%20400%
ProcessVisibilityFalseWhenSetAfterLoading()0%20400%
ProcessHideListProperly_HeadHidden()0%12300%
ProcessHideListProperly_HeadShowing()0%12300%
ProcessExpression()0%12300%
ChangeWearablesRepresentationWhenBodyShapeChanges()0%20400%
CleanWearableHidesAndReplaces(...)0%6200%

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        {
 024            yield return base.SetUp();
 25
 026            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            };
 036            catalog = AvatarAssetsTestHelpers.CreateTestCatalogLocal();
 37
 038            var avatarShape = AvatarShapeTestHelpers.CreateAvatarShape(scene, avatarModel);
 039            yield return new DCL.WaitUntil(() => avatarShape.everythingIsLoaded, 20);
 40
 041            avatarRenderer = avatarShape.avatarRenderer;
 042        }
 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        {
 049            var wearablePromise1 = CatalogController.RequestWearable("Invalid_id");
 050            var wearablePromise2 = CatalogController.RequestWearable("Scioli_right_arm");
 051            var wearablePromise3 = CatalogController.RequestWearable("Peron_hands");
 52
 053            yield return wearablePromise1;
 054            Assert.AreEqual("The request for the wearable 'Invalid_id' has exceed the set timeout!", wearablePromise1.er
 55
 056            yield return wearablePromise2;
 057            Assert.AreEqual("The request for the wearable 'Scioli_right_arm' has exceed the set timeout!", wearablePromi
 58
 059            yield return wearablePromise3;
 060            Assert.AreEqual("The request for the wearable 'Peron_hands' has exceed the set timeout!", wearablePromise3.e
 061        }
 62
 63        [UnityTest]
 64        [Category("Explicit")]
 65        [Explicit("Test too slow")]
 66        public IEnumerator ProcessVisibilityTrueWhenSetBeforeLoading()
 67        {
 68            //Clean hides/replaces to avoid interferences
 069            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 070            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 71
 072            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 073            avatarRenderer.SetVisibility(true);
 74
 075            bool ready = false;
 076            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 077            yield return new DCL.WaitUntil(() => ready);
 78
 079            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => x.enabled
 080        }
 81
 82        [UnityTest]
 83        [Category("Explicit")]
 84        [Explicit("Test too slow")]
 85        public IEnumerator ProcessVisibilityFalseWhenSetBeforeLoading()
 86        {
 87            //Clean hides/replaces to avoid interferences
 088            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 089            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 90
 091            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 092            avatarRenderer.SetVisibility(false);
 93
 094            bool ready = false;
 095            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 096            yield return new DCL.WaitUntil(() => ready);
 97
 098            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => !x.enable
 099        }
 100
 101        [UnityTest]
 102        [Category("Explicit")]
 103        [Explicit("Test too slow")]
 104        public IEnumerator ProcessVisibilityTrueWhenSetWhileLoading()
 105        {
 106            //Clean hides/replaces to avoid interferences
 0107            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 0108            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 109
 0110            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 111
 0112            bool ready = false;
 0113            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0114            avatarRenderer.SetVisibility(true);
 0115            yield return new DCL.WaitUntil(() => ready);
 116
 0117            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => x.enabled
 0118        }
 119
 120        [UnityTest]
 121        [Category("Explicit")]
 122        [Explicit("Test too slow")]
 123        public IEnumerator ProcessVisibilityFalseWhenSetWhileLoading()
 124        {
 125            //Clean hides/replaces to avoid interferences
 0126            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 0127            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 128
 0129            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 130
 0131            bool ready = false;
 0132            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0133            avatarRenderer.SetVisibility(false);
 0134            yield return new DCL.WaitUntil(() => ready);
 135
 0136            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => !x.enable
 0137        }
 138
 139        [UnityTest]
 140        [Category("Explicit")]
 141        [Explicit("Test too slow")]
 142        public IEnumerator ProcessVisibilityTrueWhenSetAfterLoading()
 143        {
 144            //Clean hides/replaces to avoid interferences
 0145            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 0146            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 147
 0148            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 149
 0150            bool ready = false;
 0151            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0152            yield return new DCL.WaitUntil(() => ready);
 0153            avatarRenderer.SetVisibility(true);
 154
 0155            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => x.enabled
 0156        }
 157
 158        [UnityTest]
 159        [Category("Explicit")]
 160        [Explicit("Test too slow")]
 161        public IEnumerator ProcessVisibilityFalseWhenSetAfterLoading()
 162        {
 163            //Clean hides/replaces to avoid interferences
 0164            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 0165            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 166
 0167            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 168
 0169            bool ready = false;
 0170            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0171            yield return new DCL.WaitUntil(() => ready);
 0172            avatarRenderer.SetVisibility(false);
 173
 0174            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).myAssetRenderers.All(x => !x.enable
 0175        }
 176
 177        [UnityTest]
 178        [Category("Explicit")]
 179        [Explicit("Test too slow")]
 180        public IEnumerator ProcessHideListProperly_HeadHidden()
 181        {
 182            //Clean hides/replaces to avoid interferences
 0183            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 0184            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 0185            catalog.Get(SUNGLASSES_ID).data.hides = new [] { WearableLiterals.Misc.HEAD };
 186
 0187            avatarModel.wearables = new List<string>() { SUNGLASSES_ID };
 188
 0189            bool ready = false;
 0190            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0191            yield return new DCL.WaitUntil(() => ready);
 192
 0193            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).headRenderer.enabled);
 0194            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyebrowsRenderer.enabled);
 0195            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyesRenderer.enabled);
 0196            Assert.IsFalse(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).mouthRenderer.enabled);
 0197        }
 198
 199        [UnityTest]
 200        [Category("Explicit")]
 201        [Explicit("Test too slow")]
 202        public IEnumerator ProcessHideListProperly_HeadShowing()
 203        {
 204            //Clean hides/replaces to avoid interferences
 0205            CleanWearableHidesAndReplaces(SUNGLASSES_ID);
 0206            CleanWearableHidesAndReplaces(BLUE_BANDANA_ID);
 207
 0208            avatarModel.wearables = new List<string>() { SUNGLASSES_ID };
 209
 0210            bool ready = false;
 0211            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0212            yield return new DCL.WaitUntil(() => ready);
 213
 0214            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).headRenderer.enabled);
 0215            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyebrowsRenderer.enabled);
 0216            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).eyesRenderer.enabled);
 0217            Assert.IsTrue(AvatarRenderer_Mock.GetBodyShapeController(avatarRenderer).mouthRenderer.enabled);
 0218        }
 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        {
 0227            var animator = avatarRenderer.animator;
 0228            var timestamp = DateTime.UtcNow.Ticks;
 229
 0230            avatarModel.expressionTriggerId = expressionId;
 0231            avatarModel.expressionTriggerTimestamp = timestamp;
 232
 0233            bool ready = false;
 0234            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0235            yield return new DCL.WaitUntil(() => ready);
 236
 0237            Assert.AreEqual(animator.blackboard.expressionTriggerId, expressionId);
 0238            Assert.AreEqual(animator.blackboard.expressionTriggerTimestamp, timestamp);
 0239        }
 240
 241        [UnityTest]
 242        [Category("Explicit")]
 243        [Explicit("Test too slow")]
 244        public IEnumerator ChangeWearablesRepresentationWhenBodyShapeChanges()
 245        {
 0246            string wearableId = "dcl://base-avatars/MultipleRepresentations";
 0247            avatarModel.wearables = new List<string> { wearableId };
 0248            avatarModel.bodyShape = WearableLiterals.BodyShapes.MALE;
 249
 0250            bool ready = false;
 0251            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0252            yield return new DCL.WaitUntil(() => ready);
 253
 0254            var wearableController = avatarRenderer.wearableControllers.Values.FirstOrDefault(x => x.id == wearableId);
 0255            Assert.NotNull(wearableController);
 0256            Assert.AreEqual("M_Feet_Espadrilles.glb" , wearableController.lastMainFileLoaded);
 257
 0258            avatarModel.bodyShape = WearableLiterals.BodyShapes.FEMALE;
 0259            ready = false;
 0260            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 0261            yield return new DCL.WaitUntil(() => ready);
 262
 0263            wearableController = avatarRenderer.wearableControllers.Values.FirstOrDefault(x => x.id == wearableId);
 0264            Assert.NotNull(wearableController);
 0265            Assert.AreEqual("Feet_XmasSockets.glb" , wearableController.lastMainFileLoaded);
 0266        }
 267
 268        private void CleanWearableHidesAndReplaces(string id)
 269        {
 0270            catalog.Get(id).data.hides = new string[] { };
 0271            catalog.Get(id).data.replaces = new string[] { };
 0272            foreach (WearableItem.Representation representation in catalog.Get(id).data.representations)
 273            {
 0274                representation.overrideHides = new string[] { };
 0275                representation.overrideReplaces = new string[] { };
 276            }
 0277        }
 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        {
 289            yield return base.SetUp();
 290
 291            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
 302            AvatarAssetsTestHelpers.CreateTestCatalogLocal();
 303
 304            var avatarShape = AvatarShapeTestHelpers.CreateAvatarShape(scene, avatarModel);
 305            yield return new DCL.WaitUntil(() => avatarShape.everythingIsLoaded, 20);
 306
 307            avatarRenderer = avatarShape.avatarRenderer;
 308            animator = avatarRenderer.animator;
 309        }
 310
 311        [UnityTest]
 312        [Category("Explicit")]
 313        [Explicit("Test too slow")]
 314        public IEnumerator NotTriggerExpressionWithSameTimestamp()
 315        {
 316            avatarModel.expressionTriggerId = "wave";
 317            avatarModel.expressionTriggerTimestamp = 1;
 318            animator.blackboard.expressionTriggerTimestamp = 1;
 319
 320            bool ready = false;
 321            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 322            yield return new DCL.WaitUntil(() => ready);
 323
 324            Assert.True(animator.currentState != animator.State_Expression);
 325        }
 326
 327        [UnityTest]
 328        [Category("Explicit")]
 329        [Explicit("Test too slow")]
 330        public IEnumerator TriggerExpressionWithSameTimestamp()
 331        {
 332            avatarModel.expressionTriggerId = "wave";
 333            avatarModel.expressionTriggerTimestamp = DateTime.UtcNow.Ticks;
 334            animator.blackboard.expressionTriggerTimestamp = -1;
 335
 336            bool ready = false;
 337            avatarRenderer.ApplyModel(avatarModel, () => ready = true, null);
 338            yield return new DCL.WaitUntil(() => ready);
 339
 340            Assert.True(animator.currentState == animator.State_Expression);
 341        }
 342    }
 343}
Generated by: ReportGenerator 4.8.9.0
07/13/2021 - 19:40:13
GitHub | www.palmmedia.de

Methods/Properties

SetUp()
FailGracefullyWhenIdsCannotBeResolved()
ProcessVisibilityTrueWhenSetBeforeLoading()
ProcessVisibilityFalseWhenSetBeforeLoading()
ProcessVisibilityTrueWhenSetWhileLoading()
ProcessVisibilityFalseWhenSetWhileLoading()
ProcessVisibilityTrueWhenSetAfterLoading()
ProcessVisibilityFalseWhenSetAfterLoading()
ProcessHideListProperly_HeadHidden()
ProcessHideListProperly_HeadShowing()
ProcessExpression()
ChangeWearablesRepresentationWhenBodyShapeChanges()
CleanWearableHidesAndReplaces(System.String)