public IEnumerator UnloadWhenEntityDestroyedBeforeFinishing()
{
GameObject meshRootGameObject = new GameObject();
string url = TestAssetsUtils.GetPath() + "/GLB/Trunk/Trunk.glb";
IDCLEntity entity = Substitute.For <IDCLEntity>();
entity.meshRootGameObject.Returns(meshRootGameObject);
LoadWrapper_GLTF wrapper = Substitute.ForPartsOf <LoadWrapper_GLTF>();
wrapper.entity = entity;
wrapper.customContentProvider = new ContentProvider();
bool loaded = false;
bool failed = false;
bool unloaded = false;
wrapper.WhenForAnyArgs(x => x.Unload()).Do((info) => unloaded = true);
wrapper.Load(url, loadWrapper => loaded = true, loadWrapper => failed = true);
entity.OnCleanupEvent?.Invoke(entity);
yield return(new WaitUntil(() => loaded || failed || unloaded));
Object.Destroy(meshRootGameObject);
Assert.IsTrue(unloaded, "Unload should be called if entity is cleaned up while loading mesh");
}
protected override AssetPromise_GLTF CreatePromise()
{
string url = TestAssetsUtils.GetPath() + "/GLB/Lantern/Lantern.glb";
var prom = new AssetPromise_GLTF(contentProvider, url);
return(prom);
}
protected override IEnumerator SetUp()
{
yield return(base.SetUp());
TestHelpers.CreateSceneEntity(scene, ENTITY_ID);
TestHelpers.CreateAndSetShape(scene, ENTITY_ID, DCL.Models.CLASS_ID.GLTF_SHAPE, JsonConvert.SerializeObject(
new
{
src = TestAssetsUtils.GetPath() + "/GLB/Trunk/Trunk.glb"
}));
LoadWrapper gltfShape = GLTFShape.GetLoaderForEntity(scene.entities[ENTITY_ID]);
yield return(new DCL.WaitUntil(() => gltfShape.alreadyLoaded));
outlinerController = new BIWOutlinerController();
entityHandler = new BIWEntityHandler();
var referencesController = BIWTestHelper.CreateReferencesControllerWithGenericMocks(
outlinerController,
entityHandler
);
outlinerController.Init(referencesController);
entityHandler.Init(referencesController);
entityHandler.EnterEditMode(scene);
outlinerController.EnterEditMode(scene);
entity = entityHandler.GetConvertedEntity(scene.entities[ENTITY_ID]);
}
public static BaseDictionary <string, WearableItem> CreateTestCatalogLocal()
{
List <WearableItemDummy> wearables = Object.Instantiate(Resources.Load <WearableItemDummyListVariable>("TestCatalogArrayLocalAssets")).list;
foreach (var wearableItem in wearables)
{
wearableItem.baseUrl = TestAssetsUtils.GetPath() + "/Avatar/Assets/";
foreach (var rep in wearableItem.data.representations)
{
rep.contents = rep.contents.Select((x) =>
{
x.hash = x.key;
return(x);
})
.ToArray();
}
wearableItem.thumbnail = "";
}
CatalogController.wearableCatalog.Clear();
var dummyWereables = wearables.Select(x => new KeyValuePair <string, WearableItem>(x.id, x)).ToArray();
foreach (var item in dummyWereables)
{
CatalogController.wearableCatalog.Add(item.Key, item.Value);
}
return(CatalogController.wearableCatalog);
}
public IEnumerator WorkCorrectlyWhenAttachedBeforeShape()
{
IDCLEntity entity = TestHelpers.CreateSceneEntity(scene);
DCLTexture dclTexture = TestHelpers.CreateDCLTexture(
scene,
TestAssetsUtils.GetPath() + "/Images/atlas.png",
DCLTexture.BabylonWrapMode.CLAMP,
FilterMode.Bilinear);
yield return(dclTexture.routine);
BasicMaterial mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model>
(scene, CLASS_ID.BASIC_MATERIAL,
new BasicMaterial.Model
{
texture = dclTexture.id,
alphaTest = 0.5f
});
yield return(mat.routine);
TestHelpers.SharedComponentAttach(mat, entity);
SphereShape shape = TestHelpers.SharedComponentCreate <SphereShape, SphereShape.Model>(scene,
CLASS_ID.SPHERE_SHAPE,
new SphereShape.Model {
});
TestHelpers.SharedComponentAttach(shape, entity);
Assert.IsTrue(entity.meshRootGameObject != null);
Assert.IsTrue(entity.meshRootGameObject.GetComponent <MeshRenderer>() != null);
Assert.AreEqual(entity.meshRootGameObject.GetComponent <MeshRenderer>().sharedMaterial, mat.material);
}
public IEnumerator VideoTextureReplaceOtherTextureCorrectly()
{
DCLVideoTexture videoTexture = CreateDCLVideoTexture(scene, "it-wont-load-during-test");
yield return(videoTexture.routine);
Assert.IsTrue(videoTexture.attachedMaterials.Count == 0, "DCLVideoTexture started with attachedMaterials != 0");
DCLTexture dclTexture = TestHelpers.CreateDCLTexture(
scene,
TestAssetsUtils.GetPath() + "/Images/atlas.png",
DCLTexture.BabylonWrapMode.CLAMP,
FilterMode.Bilinear);
yield return(dclTexture.routine);
BasicMaterial mat = TestHelpers.SharedComponentCreate <BasicMaterial, BasicMaterial.Model>
(scene, CLASS_ID.BASIC_MATERIAL,
new BasicMaterial.Model
{
texture = dclTexture.id
});
yield return(mat.routine);
yield return(TestHelpers.SharedComponentUpdate <BasicMaterial, BasicMaterial.Model>(mat, new BasicMaterial.Model()
{
texture = videoTexture.id
}));
Assert.IsTrue(videoTexture.attachedMaterials.Count == 1, $"did DCLVideoTexture attach to material? {videoTexture.attachedMaterials.Count} expected 1");
}
private void FillWithTestCatalog()
{
string file = "TestCatalog.json";
var catalogJson = File.ReadAllText(TestAssetsUtils.GetPathRaw() + $"/Avatar/{file}"); //Utils.GetTestAssetPath returns an URI not compatible with the really convenient File.ReadAllText
list = Newtonsoft.Json.JsonConvert.DeserializeObject <WearableItemDummy[]>(catalogJson).ToList(); // JsonUtility cannot deserialize jsons whose root is an array
}
public IEnumerator NotFailIfExternalTexturesAreMissing()
{
ContentServerUtils.MappingPair[] input =
{
new ContentServerUtils.MappingPair {
file = "SimpleCubeWithSharedNormal.gltf", hash = "SimpleCubeWithSharedNormal.gltf"
},
new ContentServerUtils.MappingPair {
file = "SimpleCubeWithSharedNormal.bin", hash = "SimpleCubeWithSharedNormal.bin"
},
};
core.settings.baseUrl = TestAssetsUtils.GetPath() + "/GLTF/SimpleCube/";
env = ABConverter.Environment.CreateWithDefaultImplementations();
core = new ABConverter.Core(env, core.settings);
core.Convert(input);
yield return(new WaitUntil(() => core.state.step == ABConverter.Core.State.Step.FINISHED));
Assert.IsTrue(core.state.lastErrorCode == ABConverter.Core.ErrorCodes.SUCCESS);
LogAssert.Expect(LogType.Error, new Regex(@"^.*?Buffer file not found"));
LogAssert.Expect(LogType.Error, new Regex(@"^.*?Buffer file not found"));
}
void Update()
{
if (Input.GetKeyUp(KeyCode.Z))
{
counter++;
counter %= 3;
switch (counter)
{
case 0:
string url = TestAssetsUtils.GetPath() + "/GLB/TrunkSeparatedTextures/Trunk.glb";
Generate(url);
break;
case 1:
string url2 = TestAssetsUtils.GetPath() + "/GLB/Lantern/Lantern.glb";
Generate(url2);
break;
case 2:
string url3 = TestAssetsUtils.GetPath() + "/GLB/DamagedHelmet/DamagedHelmet.glb";
Generate(url3);
break;
}
}
else if (Input.GetKeyUp(KeyCode.X))
{
if (promiseList.Count > 0)
{
var promiseToRemove = promiseList[Random.Range(0, promiseList.Count)];
keeper.Forget(promiseToRemove);
promiseList.Remove(promiseToRemove);
}
}
}
public IEnumerator NotGenerateColorMapsWithDXTnm()
{
ContentServerUtils.MappingPair[] input =
{
new ContentServerUtils.MappingPair {
file = "SimpleCubeWithSharedNormal.gltf", hash = "SimpleCubeWithSharedNormal.gltf"
},
new ContentServerUtils.MappingPair {
file = "SimpleCubeWithSharedNormal.bin", hash = "SimpleCubeWithSharedNormal.bin"
},
new ContentServerUtils.MappingPair {
file = "Textures/Test.png", hash = "Test.png"
}
};
core.settings.baseUrl = TestAssetsUtils.GetPath() + "/GLTF/SimpleCube/";
core.settings.verbose = true;
core.settings.dumpOnly = true;
core.settings.deleteDownloadPathAfterFinished = false;
env = ABConverter.Environment.CreateWithDefaultImplementations();
core = new ABConverter.Core(env, core.settings);
core.Convert(input);
yield return(new WaitUntil(() => core.state.step == ABConverter.Core.State.Step.FINISHED));
Assert.IsTrue(core.state.lastErrorCode == ABConverter.Core.ErrorCodes.SUCCESS);
string importerPath = $"{core.finalDownloadedPath}Test.png{ABConverter.Config.DASH}Test.png.png";
TextureImporter importer = env.assetDatabase.GetImporterAtPath(importerPath) as TextureImporter;
Assert.IsTrue(importer != null, "Texture importer is null!");
Assert.IsTrue(TextureImporterType.NormalMap != importer.textureType, "Texture is used for color! It shouldn't be never importer as normal map!");
}
IEnumerator Start()
{
yield return(InitScene());
string entityId = "1";
var entity = TestHelpers.CreateSceneEntity(scene, entityId);
string shapeId = TestHelpers.CreateAndSetShape(scene, entityId, DCL.Models.CLASS_ID.GLTF_SHAPE,
JsonConvert.SerializeObject(new
{
src = TestAssetsUtils.GetPath() + "/GLB/Lantern/Lantern.glb"
}));
LoadWrapper_GLTF gltfShape = GLTFShape.GetLoaderForEntity(entity) as LoadWrapper_GLTF;
yield return(new DCL.WaitUntil(() => gltfShape.alreadyLoaded, 7f));
TestHelpers.SetEntityTransform(scene, entity, new Vector3(8, -1, 8), Quaternion.identity, new Vector3(0.5f, 0.5f, 0.5f));
var onClickComponentModel = new OnClick.Model()
{
type = OnClick.NAME,
uuid = "pointerevent-1",
button = this.button.ToString()
};
var onClickComponent = TestHelpers.EntityComponentCreate <OnClick, OnClick.Model>(scene, entity, onClickComponentModel, CLASS_ID_COMPONENT.UUID_CALLBACK);
scene.sceneLifecycleHandler.SetInitMessagesDone();
OnPointerEvent.enableInteractionHoverFeedback = true;
}
public static IEnumerator GLTFShapeIsResetWhenReenteringBounds(ParcelScene scene)
{
var entity = TestHelpers.CreateSceneEntity(scene);
TestHelpers.SetEntityTransform(scene, entity, new DCLTransform.Model {
position = new Vector3(18, 1, 18)
});
TestHelpers.CreateAndSetShape(scene, entity.entityId, DCL.Models.CLASS_ID.GLTF_SHAPE, JsonConvert.SerializeObject(
new
{
src = TestAssetsUtils.GetPath() + "/GLB/PalmTree_01.glb"
}));
LoadWrapper gltfShape = GLTFShape.GetLoaderForEntity(entity);
yield return(new UnityEngine.WaitUntil(() => gltfShape.alreadyLoaded));
yield return(null);
AssertMeshIsInvalid(entity.meshesInfo);
// Move object to surpass the scene boundaries
TestHelpers.SetEntityTransform(scene, entity, new DCLTransform.Model {
position = new Vector3(8, 1, 8)
});
yield return(null);
yield return(null);
AssertMeshIsValid(entity.meshesInfo);
}
public IEnumerator OBJShapeUpdate()
{
string entityId = "1";
TestHelpers.CreateSceneEntity(scene, entityId);
Material placeholderLoadingMaterial = Resources.Load <Material>("Materials/AssetLoading");
yield return(null);
Assert.IsTrue(scene.entities[entityId].meshRootGameObject == null,
"Since the shape hasn't been updated yet, the child mesh shouldn't exist");
TestHelpers.CreateAndSetShape(scene, entityId, DCL.Models.CLASS_ID.OBJ_SHAPE, JsonConvert.SerializeObject(
new
{
src = TestAssetsUtils.GetPath() + "/OBJ/teapot.obj"
}));
LoadWrapper objShape = LoadableShape.GetLoaderForEntity(scene.entities[entityId]);
yield return(new WaitUntil(() => objShape.alreadyLoaded));
Assert.IsTrue(scene.entities[entityId].meshRootGameObject != null,
"Every entity with a shape should have the mandatory 'Mesh' object as a child");
var childRenderer = scene.entities[entityId].meshRootGameObject.GetComponentInChildren <MeshRenderer>();
Assert.IsTrue(childRenderer != null,
"Since the shape has already been updated, the child renderer should exist");
Assert.AreNotSame(placeholderLoadingMaterial, childRenderer.sharedMaterial,
"Since the shape has already been updated, the child renderer found shouldn't have the 'AssetLoading' placeholder material");
}
public IEnumerator BeCreatedProperly()
{
DCLTexture texture =
TestHelpers.CreateDCLTexture(scene, TestAssetsUtils.GetPath() + "/Images/atlas.png");
yield return(texture.routine);
PBRMaterial matPBR = TestHelpers.CreateEntityWithPBRMaterial(scene,
new PBRMaterial.Model
{
albedoTexture = texture.id,
metallic = 0,
roughness = 1,
},
out IDCLEntity entity);
yield return(matPBR.routine);
Assert.IsTrue(entity.meshRootGameObject != null,
"Every entity with a shape should have the mandatory 'Mesh' object as a child");
var meshRenderer = entity.meshRootGameObject.GetComponent <MeshRenderer>();
Assert.IsTrue(meshRenderer != null, "MeshRenderer must exist");
var assignedMaterial = meshRenderer.sharedMaterial;
Assert.IsTrue(meshRenderer != null, "MeshRenderer.sharedMaterial must be the same as assignedMaterial");
Assert.AreEqual(assignedMaterial, matPBR.material, "Assigned material");
var loadedTexture = meshRenderer.sharedMaterial.GetTexture("_BaseMap");
Assert.IsTrue(loadedTexture != null, "Texture must be loaded");
Assert.AreEqual(texture.texture, loadedTexture, "Texture data must be correct");
}
public IEnumerator NotDestroySharedTextureWhenDisposed()
{
DCLTexture texture =
TestHelpers.CreateDCLTexture(scene, TestAssetsUtils.GetPath() + "/Images/atlas.png");
yield return(texture.routine);
PBRMaterial mat = TestHelpers.CreateEntityWithPBRMaterial(scene,
new PBRMaterial.Model
{
albedoTexture = texture.id,
metallic = 0,
roughness = 1,
},
out IDCLEntity entity1);
yield return(mat.routine);
PBRMaterial mat2 = TestHelpers.CreateEntityWithPBRMaterial(scene,
new PBRMaterial.Model
{
albedoTexture = texture.id,
metallic = 0,
roughness = 1,
},
out IDCLEntity entity2);
yield return(mat2.routine);
TestHelpers.SharedComponentDispose(mat);
Assert.IsTrue(texture.texture != null, "Texture should persist because is used by the other material!!");
}
protected override AssetPromise_Gif CreatePromise()
{
string url = TestAssetsUtils.GetPath() + "/Images/gif1.gif";
var prom = new AssetPromise_Gif(url);
return(prom);
}
protected AssetPromise_Texture CreatePromise(TextureWrapMode wrapmode, FilterMode filterMode)
{
string url = TestAssetsUtils.GetPath() + "/Images/atlas.png";
AssetPromise_Texture prom = new AssetPromise_Texture(url, wrapmode, filterMode);
return(prom);
}
public IEnumerator VisibleProperty()
{
string entityId = "entityId";
TestHelpers.CreateSceneEntity(scene, entityId);
var entity = scene.entities[entityId];
yield return(null);
// Create shape component
var shapeModel = new LoadableShape <LoadWrapper_GLTF, LoadableShape.Model> .Model();
shapeModel.src = TestAssetsUtils.GetPath() + "/GLB/PalmTree_01.glb";
var shapeComponent = TestHelpers.SharedComponentCreate <LoadableShape <LoadWrapper_GLTF, LoadableShape.Model>, LoadableShape <LoadWrapper_GLTF, LoadableShape.Model> .Model>(scene, CLASS_ID.GLTF_SHAPE, shapeModel);
yield return(shapeComponent.routine);
TestHelpers.SharedComponentAttach(shapeComponent, entity);
var shapeLoader = GLTFShape.GetLoaderForEntity(entity);
yield return(new WaitUntil(() => shapeLoader.alreadyLoaded));
yield return(TestHelpers.TestShapeVisibility(shapeComponent, shapeModel, entity));
}
public IEnumerator WaitForPromisesOfSameTextureWithDifferentSettings()
{
// default texture (no settings)
var prom = CreatePromise(TestAssetsUtils.GetPath() + "/Images/atlas.png");
Asset_Texture asset = null;
prom.OnSuccessEvent += (x) => { asset = x; };
keeper.Keep(prom);
// same texture but with settings
var prom2 = CreatePromise(TestAssetsUtils.GetPath() + "/Images/atlas.png", (int)TextureWrapMode.Repeat, (int)FilterMode.Trilinear);
Asset_Texture asset2 = null;
prom.OnSuccessEvent += (x) => { asset2 = x; };
keeper.Keep(prom2);
// different texture
var prom3 = CreatePromise(TestAssetsUtils.GetPath() + "/Images/avatar.png");
Asset_Texture asset3 = null;
prom.OnSuccessEvent += (x) => { asset3 = x; };
keeper.Keep(prom3);
Assert.AreEqual(AssetPromiseState.LOADING, prom.state);
Assert.AreEqual(AssetPromiseState.WAITING, prom2.state);
Assert.AreEqual(AssetPromiseState.LOADING, prom3.state);
return(null);
}
public IEnumerator PreExistentShapeImmediateUpdate()
{
string entityId = "1";
TestHelpers.CreateSceneEntity(scene, entityId);
var componentId = TestHelpers.CreateAndSetShape(scene, entityId, DCL.Models.CLASS_ID.GLTF_SHAPE, JsonConvert.SerializeObject(
new
{
src = TestAssetsUtils.GetPath() + "/GLB/Trunk/Trunk.glb"
}));
LoadWrapper gltfShape = GLTFShape.GetLoaderForEntity(scene.entities[entityId]);
yield return(new WaitUntil(() => gltfShape.alreadyLoaded));
TestHelpers.UpdateShape(scene, componentId, JsonConvert.SerializeObject(
new
{
src = TestAssetsUtils.GetPath() + "/GLB/PalmTree_01.glb"
}));
gltfShape = GLTFShape.GetLoaderForEntity(scene.entities[entityId]);
yield return(new WaitUntil(() => gltfShape.alreadyLoaded));
Assert.AreEqual(1,
scene.entities[entityId].gameObject.GetComponentsInChildren <InstantiatedGLTFObject>().Length,
"Only 1 'InstantiatedGLTFObject' should remain once the GLTF shape has been updated");
}
public IEnumerator AttachedGetsReplacedOnNewAttachment()
{
var entity = TestHelpers.CreateSceneEntity(scene);
// set first GLTF
string gltfId1 = TestHelpers.CreateAndSetShape(scene, entity.entityId, DCL.Models.CLASS_ID.GLTF_SHAPE,
JsonConvert.SerializeObject(new
{
src = TestAssetsUtils.GetPath() + "/GLB/PalmTree_01.glb"
}));
var gltf1 = scene.GetSharedComponent(gltfId1);
LoadWrapper gltfLoader = GLTFShape.GetLoaderForEntity(entity);
yield return(new WaitUntil(() => gltfLoader.alreadyLoaded));
Assert.AreEqual(gltf1, entity.GetSharedComponent(typeof(BaseShape)));
// set second GLTF
string gltfId2 = TestHelpers.CreateAndSetShape(scene, entity.entityId, DCL.Models.CLASS_ID.GLTF_SHAPE,
JsonConvert.SerializeObject(new
{
src = TestAssetsUtils.GetPath() + "/GLB/Trunk/Trunk.glb"
}));
gltfLoader = GLTFShape.GetLoaderForEntity(entity);
yield return(new WaitUntil(() => gltfLoader.alreadyLoaded));
Assert.AreEqual(scene.GetSharedComponent(gltfId2), entity.GetSharedComponent(typeof(BaseShape)));
Assert.IsFalse(gltf1.GetAttachedEntities().Contains(entity));
}
public IEnumerator AlbedoTexture_AlbedoAlpha(float alpha)
{
yield return(InitVisualTestsScene($"PBRMaterialVisualTests_AlbedoTexture_AlbedoAlpha_{alpha.ToString(CultureInfo.InvariantCulture)}"));
VisualTestHelpers.SetSSAOActive(true);
Vector3 camTarget = new Vector3(5, 1, 5);
VisualTestHelpers.RepositionVisualTestsCamera(VisualTestController.i.camera, new Vector3(4.6f, 1.8f, 0.6f), camTarget);
DCLTexture texture = TestHelpers.CreateDCLTexture(scene, TestAssetsUtils.GetPath() + "/Images/avatar.png");
yield return(texture.routine);
PlaneShape plane = TestHelpers.CreateEntityWithPlaneShape(scene, new Vector3(5, 1, 5), true);
IDCLEntity planeEntity = plane.attachedEntities.FirstOrDefault();
TestHelpers.SetEntityTransform(scene, planeEntity, new Vector3(5, 1, 5), Quaternion.Euler(0, 0, 180), Vector3.one * 3);
PBRMaterial planeMaterial = TestHelpers.AttachPBRMaterialToEntity(scene, planeEntity, new PBRMaterial.Model
{
transparencyMode = 2,
albedoTexture = texture.id,
albedoColor = new Color(1, 1, 1, alpha)
});
yield return(plane.routine);
yield return(planeMaterial.routine);
yield return(null);
yield return(VisualTestHelpers.TakeSnapshot());
}
public IEnumerator AlphaTextureShouldWork()
{
yield return(InitVisualTestsScene("PBRMaterialVisualTests_AlphaTextureShouldWork"));
DCLTexture texture = TestHelpers.CreateDCLTexture(scene, TestAssetsUtils.GetPath() + "/Images/alphaTexture.png");
yield return(texture.routine);
Vector3 camTarget = new Vector3(5, 2, 5);
VisualTestHelpers.RepositionVisualTestsCamera(VisualTestController.i.camera, camTarget - new Vector3(2, -1, 2), camTarget);
PBRMaterial matPBR = TestHelpers.CreateEntityWithPBRMaterial(scene, new PBRMaterial.Model
{
albedoTexture = texture.id,
transparencyMode = 2,
albedoColor = Color.blue
}, camTarget, out IDCLEntity entity);
yield return(matPBR.routine);
yield return(null);
yield return(VisualTestHelpers.TakeSnapshot());
}
protected AssetPromise_Texture CreatePromise()
{
string url = TestAssetsUtils.GetPath() + "/Images/atlas.png";
var prom = new AssetPromise_Texture(url);
return(prom);
}
protected override AssetPromise_AB_GameObject CreatePromise()
{
string contentUrl = TestAssetsUtils.GetPath() + "/AssetBundles/";
string hash = "QmNS4K7GaH63T9rhAfkrra7ADLXSEeco8FTGknkPnAVmKM";
var prom = new AssetPromise_AB_GameObject(contentUrl, hash);
return(prom);
}
public static AvatarModel GetTestAvatarModel(string name, string fileName)
{
var avatarjson = File.ReadAllText(TestAssetsUtils.GetPathRaw() + "/Avatar/" + fileName);
AvatarModel model = JsonUtility.FromJson <AvatarModel>(avatarjson);
model.name = name;
return(model);
}
protected override AssetPromise_AB CreatePromise()
{
string contentUrl = TestAssetsUtils.GetPath() + "/AssetBundles/";
string hash = "QmYACL8SnbXEonXQeRHdWYbfm8vxvaFAWnsLHUaDG4ABp5";
var prom = new AssetPromise_AB(contentUrl, hash);
return(prom);
}
public void Texture_OnReadyBeforeLoading()
{
DCLTexture dclTexture = TestHelpers.CreateDCLTexture(scene, TestAssetsUtils.GetPath() + "/Images/avatar.png");
bool isOnReady = false;
dclTexture.CallWhenReady((x) => { isOnReady = true; });
Assert.IsTrue(isOnReady); //DCLTexture is ready on creation
}
public void AudioClip_OnReadyBeforeLoading()
{
DCLAudioClip dclAudioClip = CreateAudioClip(TestAssetsUtils.GetPath() + "/Audio/short_effect.ogg", true, true, 1);
bool isOnReady = false;
dclAudioClip.CallWhenReady((x) => { isOnReady = true; });
Assert.IsTrue(isOnReady); //DCLAudioClip is ready on creation
}
public IEnumerator FailCorrectlyWhenGivenWrongURL()
{
var keeper = new AssetPromiseKeeper_GLTF();
//NOTE(Brian): Expect the 404 error
LogAssert.Expect(LogType.Error, new Regex("^*.?404"));
string url = TestAssetsUtils.GetPath() + "/non_existing_url.glb";
AssetPromise_GLTF prom = new AssetPromise_GLTF(scene.contentProvider, url);
Asset_GLTF asset = null;
bool failEventCalled1 = false;
prom.OnSuccessEvent += (x) => { asset = x; };
prom.OnFailEvent += (x) => { failEventCalled1 = true; };
AssetPromise_GLTF prom2 = new AssetPromise_GLTF(scene.contentProvider, url);
Asset_GLTF asset2 = null;
bool failEventCalled2 = false;
prom2.OnSuccessEvent += (x) => { asset2 = x; };
prom2.OnFailEvent += (x) => { failEventCalled2 = true; };
AssetPromise_GLTF prom3 = new AssetPromise_GLTF(scene.contentProvider, url);
Asset_GLTF asset3 = null;
bool failEventCalled3 = false;
prom3.OnSuccessEvent += (x) => { asset3 = x; };
prom3.OnFailEvent += (x) => { failEventCalled3 = true; };
keeper.Keep(prom);
keeper.Keep(prom2);
keeper.Keep(prom3);
Assert.AreEqual(3, keeper.waitingPromisesCount);
yield return(prom);
yield return(prom2);
yield return(prom3);
Assert.AreNotEqual(AssetPromiseState.FINISHED, prom.state);
Assert.AreNotEqual(AssetPromiseState.FINISHED, prom2.state);
Assert.AreNotEqual(AssetPromiseState.FINISHED, prom3.state);
Assert.IsTrue(failEventCalled1);
Assert.IsTrue(failEventCalled2);
Assert.IsTrue(failEventCalled3);
Assert.IsFalse(asset != null);
Assert.IsFalse(asset2 != null);
Assert.IsFalse(asset3 != null);
Assert.IsFalse(keeper.library.Contains(asset));
Assert.AreNotEqual(1, keeper.library.masterAssets.Count);
}
