< Summary

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

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
SetUp()0%30500%
BeVisibleByDefault()0%20400%
BeHiddenByGeneralHides()0%30500%
NotBeHiddenByWrongGeneralHides()0%30500%
BeHiddenByOverrideHides()0%30500%
NotBeHiddenByOverrideHides()0%30500%
BeUnequipedProperly()0%20400%
BeUnequipedProperlyMultipleTimes()0%72800%
SetTheCorrectMaterial()0%90900%
SetTheCorrectMaterialWhenLoadingMultipleTimes()0%90900%
BeRetrievedWithoutPoolableObject()0%56700%
HideBodyShapeProperly()0%42600%
BeHiddenUntilWholeAvatarIsReady()0%30500%
AssertAllAvatarRenderers(...)0%20400%

File(s)

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

#LineLine coverage
 1using DCL;
 2using NUnit.Framework;
 3using System.Collections;
 4using System.Collections.Generic;
 5using System.Linq;
 6using UnityEngine;
 7using UnityEngine.TestTools;
 8
 9namespace AvatarShape_Tests
 10{
 11    public class WearableItemsShould : IntegrationTestSuite_Legacy
 12    {
 13        private const string SUNGLASSES_ID = "dcl://base-avatars/black_sun_glasses";
 14        private const string BLUE_BANDANA_ID = "dcl://base-avatars/blue_bandana";
 15
 16        private AvatarModel avatarModel;
 17        private BaseDictionary<string, WearableItem> catalog;
 18        private AvatarShape avatarShape;
 19
 20        [UnitySetUp]
 21        protected override IEnumerator SetUp()
 22        {
 023            SetUp_SceneController();
 024            yield return SetUp_CharacterController();
 25
 026            if (avatarShape == null)
 27            {
 028                avatarModel = new AvatarModel()
 29                {
 30                    name = " test",
 31                    hairColor = Color.white,
 32                    eyeColor = Color.white,
 33                    skinColor = Color.white,
 34                    bodyShape = WearableLiterals.BodyShapes.FEMALE,
 35                    wearables = new List<string>()
 36                        { }
 37                };
 038                catalog = AvatarAssetsTestHelpers.CreateTestCatalogLocal();
 039                avatarShape = AvatarShapeTestHelpers.CreateAvatarShape(scene, avatarModel);
 40
 041                yield return new DCL.WaitUntil(() => avatarShape.everythingIsLoaded, 20);
 42            }
 043        }
 44
 45        [UnityTest]
 46        [Explicit("Test taking too long")]
 47        [Category("Explicit")]
 48        public IEnumerator BeVisibleByDefault()
 49        {
 050            avatarModel.wearables = new List<string>() { SUNGLASSES_ID };
 51
 052            avatarShape.UpdateFromModel(avatarModel);
 053            yield return avatarShape.routine;
 54
 055            var sunglassesController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShap
 056            Assert.IsTrue(sunglassesController.myAssetRenderers.All(x => x.enabled));
 057        }
 58
 59        [UnityTest]
 60        [Explicit("Test taking too long")]
 61        [Category("Explicit")]
 62        public IEnumerator BeHiddenByGeneralHides()
 63        {
 064            var sunglasses = catalog.Get(SUNGLASSES_ID);
 065            var bandana = catalog.Get(BLUE_BANDANA_ID);
 66
 067            bandana.data.hides = new[] { sunglasses.data.category };
 068            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 069            avatarShape.UpdateFromModel(avatarModel);
 070            yield return avatarShape.routine;
 71
 072            var sunglassesController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShap
 073            var bandanaController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShape.a
 074            Assert.IsTrue(sunglassesController.myAssetRenderers.All(x => !x.enabled));
 075            Assert.IsTrue(bandanaController.myAssetRenderers.All(x => x.enabled));
 076        }
 77
 78        [UnityTest]
 79        [Explicit("Test taking too long")]
 80        [Category("Explicit")]
 81        public IEnumerator NotBeHiddenByWrongGeneralHides()
 82        {
 083            var bandana = catalog.Get(BLUE_BANDANA_ID);
 84
 085            bandana.data.hides = new[] { "NonExistentCategory" };
 086            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 087            avatarShape.UpdateFromModel(avatarModel);
 088            yield return avatarShape.routine;
 89
 090            var sunglassesController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShap
 091            var bandanaController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShape.a
 092            Assert.IsTrue(sunglassesController.myAssetRenderers.All(x => x.enabled));
 093            Assert.IsTrue(bandanaController.myAssetRenderers.All(x => x.enabled));
 094        }
 95
 96        [UnityTest]
 97        [Explicit("Test taking too long")]
 98        [Category("Explicit")]
 99        public IEnumerator BeHiddenByOverrideHides()
 100        {
 0101            var sunglasses = catalog.Get(SUNGLASSES_ID);
 0102            var bandana = catalog.Get(BLUE_BANDANA_ID);
 103
 0104            bandana.GetRepresentation(avatarModel.bodyShape).overrideHides = new[] { sunglasses.data.category };
 0105            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 0106            avatarShape.UpdateFromModel(avatarModel);
 0107            yield return avatarShape.routine;
 108
 0109            var sunglassesController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShap
 0110            var bandanaController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShape.a
 0111            Assert.IsTrue(sunglassesController.myAssetRenderers.All(x => !x.enabled));
 0112            Assert.IsTrue(bandanaController.myAssetRenderers.All(x => x.enabled));
 0113        }
 114
 115        [UnityTest]
 116        [Explicit("Test taking too long")]
 117        [Category("Explicit")]
 118        public IEnumerator NotBeHiddenByOverrideHides()
 119        {
 0120            var sunglasses = catalog.Get(SUNGLASSES_ID);
 0121            var bandana = catalog.Get(BLUE_BANDANA_ID);
 122
 0123            bandana.GetRepresentation(WearableLiterals.BodyShapes.MALE).overrideHides = new[] { sunglasses.data.category
 0124            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 0125            avatarShape.UpdateFromModel(avatarModel);
 0126            yield return avatarShape.routine;
 127
 0128            var sunglassesController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShap
 0129            var bandanaController = new WearableController_Mock(AvatarRenderer_Mock.GetWearableControllers(avatarShape.a
 0130            Assert.IsTrue(sunglassesController.myAssetRenderers.All(x => x.enabled));
 0131            Assert.IsTrue(bandanaController.myAssetRenderers.All(x => x.enabled));
 0132        }
 133
 134        [UnityTest]
 135        [Explicit("Test taking too long")]
 136        [Category("Explicit")]
 137        public IEnumerator BeUnequipedProperly()
 138        {
 0139            avatarModel.wearables = new List<string>() { SUNGLASSES_ID };
 0140            avatarShape.UpdateFromModel(avatarModel);
 0141            yield return avatarShape.routine;
 142
 0143            avatarModel.wearables = new List<string>() { };
 0144            avatarShape.UpdateFromModel(avatarModel);
 0145            yield return avatarShape.routine;
 0146            var wearableControllers = AvatarRenderer_Mock.GetWearableControllers(avatarShape.avatarRenderer);
 147
 0148            Assert.IsFalse(wearableControllers.ContainsKey(SUNGLASSES_ID));
 0149        }
 150
 151        [UnityTest]
 152        [Explicit("Test taking too long")]
 153        [Category("Explicit")]
 154        public IEnumerator BeUnequipedProperlyMultipleTimes()
 155        {
 0156            List<GameObject> containers = new List<GameObject>();
 157
 0158            for (int i = 0; i < 6; i++)
 159            {
 0160                avatarModel.wearables = new List<string>() { SUNGLASSES_ID };
 0161                avatarShape.UpdateFromModel(avatarModel);
 0162                yield return avatarShape.routine;
 0163                containers.Add(AvatarRenderer_Mock.GetWearableController(avatarShape.avatarRenderer, SUNGLASSES_ID)?.myA
 164
 0165                avatarModel.wearables = new List<string>() { };
 0166                avatarShape.UpdateFromModel(avatarModel);
 0167                yield return avatarShape.routine;
 168            }
 169
 0170            Assert.IsTrue(containers.All(x => x == null));
 0171        }
 172
 173        [UnityTest]
 174        [Explicit("Test taking too long")]
 175        [Category("Explicit")]
 176        public IEnumerator SetTheCorrectMaterial()
 177        {
 0178            avatarModel = AvatarShapeTestHelpers.GetTestAvatarModel("test", "TestAvatar.json");
 0179            avatarShape.UpdateFromModel(avatarModel);
 0180            yield return avatarShape.routine;
 181
 0182            var wearableControllers = AvatarRenderer_Mock.GetWearableMockControllers(avatarShape.avatarRenderer);
 0183            List<Material> materials = new List<Material>();
 0184            foreach (var wearableControllerMock in wearableControllers.Values)
 185            {
 0186                if (wearableControllerMock.category == WearableLiterals.Categories.EYES || wearableControllerMock.catego
 187                    continue;
 188
 0189                materials.AddRange(wearableControllerMock.myAssetContainer.GetComponentsInChildren<Renderer>().SelectMan
 190            }
 191
 0192            Assert.IsTrue(materials.All(x => x.shader.name == "DCL/Toon Shader"));
 0193        }
 194
 195        [UnityTest]
 196        [Explicit("Test taking too long")]
 197        [Category("Explicit")]
 198        public IEnumerator SetTheCorrectMaterialWhenLoadingMultipleTimes()
 199        {
 0200            avatarModel = AvatarShapeTestHelpers.GetTestAvatarModel("test", "TestAvatar.json");
 0201            avatarShape.avatarRenderer.ApplyModel(avatarModel, null, null);
 0202            avatarShape.avatarRenderer.ApplyModel(avatarModel, null, null);
 0203            avatarShape.avatarRenderer.ApplyModel(avatarModel, null, null);
 204
 0205            bool lastUpdateIsDone = false;
 0206            avatarShape.avatarRenderer.ApplyModel(avatarModel, () => lastUpdateIsDone = true, null);
 207
 0208            yield return new DCL.WaitUntil(() => lastUpdateIsDone);
 209
 0210            var wearableControllers = AvatarRenderer_Mock.GetWearableMockControllers(avatarShape.avatarRenderer);
 0211            List<Material> materials = new List<Material>();
 0212            foreach (var wearableControllerMock in wearableControllers.Values)
 213            {
 0214                if (wearableControllerMock.category == WearableLiterals.Categories.EYES || wearableControllerMock.catego
 215                    continue;
 216
 0217                materials.AddRange(wearableControllerMock.myAssetContainer.GetComponentsInChildren<Renderer>().SelectMan
 218            }
 219
 0220            Assert.IsTrue(materials.All(x => x.shader.name == "DCL/Toon Shader"));
 0221        }
 222
 223        [UnityTest]
 224        [Explicit("Test taking too long")]
 225        [Category("Explicit")]
 226        public IEnumerator BeRetrievedWithoutPoolableObject()
 227        {
 0228            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 0229            avatarShape.UpdateFromModel(avatarModel);
 0230            yield return avatarShape.routine;
 231
 0232            var sunglassesAssetContainer = AvatarRenderer_Mock.GetWearableController(avatarShape.avatarRenderer, SUNGLAS
 0233            var bandanaAssetContainer = AvatarRenderer_Mock.GetWearableController(avatarShape.avatarRenderer, BLUE_BANDA
 234
 0235            var sunglassesPoolableObject = PoolManager.i.GetPoolable(sunglassesAssetContainer);
 0236            var bandanaPoolableObject = PoolManager.i.GetPoolable(bandanaAssetContainer);
 0237            Assert.IsNull(sunglassesPoolableObject);
 0238            Assert.IsNull(bandanaPoolableObject);
 0239        }
 240
 241        [UnityTest]
 242        [Explicit("Test taking too long")]
 243        [Category("Explicit")]
 244        public IEnumerator HideBodyShapeProperly()
 245        {
 0246            catalog.Get(SUNGLASSES_ID).data.hides = new[] { WearableLiterals.Misc.HEAD };
 0247            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 0248            avatarShape.UpdateFromModel(avatarModel);
 0249            yield return avatarShape.routine;
 250
 0251            var bodyShapeAssetContainer = AvatarRenderer_Mock.GetBodyShapeController(avatarShape.avatarRenderer)?.myAsse
 0252            Assert.IsNotNull(bodyShapeAssetContainer);
 253
 0254            var renderers = bodyShapeAssetContainer.GetComponentsInChildren<Renderer>();
 0255            Assert.IsTrue(renderers.All(x => !x.enabled));
 0256        }
 257
 258        [UnityTest]
 259        [Explicit("Test taking too long")]
 260        [Category("Explicit")]
 261        public IEnumerator BeHiddenUntilWholeAvatarIsReady()
 262        {
 0263            avatarShape.avatarRenderer.CleanupAvatar();
 0264            yield return null; //NOTE(Brian): Must wait a frame in order to all gameObjects finishes destroying.
 265
 0266            avatarModel.wearables = new List<string>() { SUNGLASSES_ID, BLUE_BANDANA_ID };
 0267            avatarShape.avatarRenderer.ApplyModel(avatarModel, null, null);
 268
 0269            while (avatarShape.avatarRenderer.isLoading)
 270            {
 0271                AssertAllAvatarRenderers(false);
 0272                yield return null;
 273            }
 274
 0275            AssertAllAvatarRenderers(true);
 0276        }
 277
 278        private void AssertAllAvatarRenderers(bool shouldBeEnabled)
 279        {
 0280            Renderer[] renderers = avatarShape.avatarRenderer.GetComponentsInChildren<Renderer>(true);
 0281            foreach (var r in renderers)
 282            {
 0283                if (r.enabled)
 284                {
 0285                    if (shouldBeEnabled)
 0286                        Assert.IsTrue(r.enabled, "All renderers should be enabled on cleanup!");
 287                    else
 0288                        Assert.IsTrue(!r.enabled, "All renderers should be disabled on cleanup!");
 289                }
 290            }
 0291        }
 292    }
 293}
Generated by: ReportGenerator 4.8.9.0
07/13/2021 - 19:40:13
GitHub | www.palmmedia.de

Methods/Properties

SetUp()
BeVisibleByDefault()
BeHiddenByGeneralHides()
NotBeHiddenByWrongGeneralHides()
BeHiddenByOverrideHides()
NotBeHiddenByOverrideHides()
BeUnequipedProperly()
BeUnequipedProperlyMultipleTimes()
SetTheCorrectMaterial()
SetTheCorrectMaterialWhenLoadingMultipleTimes()
BeRetrievedWithoutPoolableObject()
HideBodyShapeProperly()
BeHiddenUntilWholeAvatarIsReady()
AssertAllAvatarRenderers(System.Boolean)