protected override void Destroy() { if (m_WrappedOp.IsValid()) { m_WrappedOp.Release(); } if (m_DepOp.IsValid()) { m_DepOp.Release(); } }
public IEnumerator ProvideResource_WhenRemote_ExceptionHandlerReceivesExceptionWithWebRequestError() { m_ResourceManager.ResourceProviders.Add(new AssetBundleProvider()); ResourceLocationBase location = new ResourceLocationBase("nonExistingResource", "http://urlThatCantPossiblyExistsaaaaaaaa.com/bundleName.bundle", typeof(AssetBundleProvider).FullName, typeof(IAssetBundleResource)); location.Data = new AssetBundleRequestOptions() { BundleName = "bundleName", Timeout = 0 }; var prevHandler = ResourceManager.ExceptionHandler; bool exceptionWithRequestResultReceived = false; ResourceManager.ExceptionHandler += (h, ex) => { exceptionWithRequestResultReceived |= ex is RemoteProviderException pEx && pEx.WebRequestResult != null; }; AsyncOperationHandle <IAssetBundleResource> handle = m_ResourceManager.ProvideResource <IAssetBundleResource>(location); yield return(handle); ResourceManager.ExceptionHandler = prevHandler; Assert.AreEqual(AsyncOperationStatus.Failed, handle.Status); Assert.IsTrue(exceptionWithRequestResultReceived); handle.Release(); }
public IEnumerator AddressablesImpl_DownloadDependenciesAsync_CantDownloadWhenGetResourceLocFailsObjectList() { // Setup yield return(Init()); var deps = new List <object>(); var provideHandle = new ProvideHandle(m_Addressables.ResourceManager, new ProviderOperation <AssetBundleResource>()); provideHandle.GetDependencies(deps); AsyncOperationHandle op = new AsyncOperationHandle(); using (new IgnoreFailingLogMessage()) { op = m_Addressables.DownloadDependenciesAsync(deps, Addressables.MergeMode.Intersection, false); yield return(op); } // Test Assert.AreEqual(AsyncOperationStatus.Failed, op.Status); Assert.IsTrue(op.OperationException.Message.Contains("InvalidKey")); Assert.IsNull(op.Result); // Cleanup op.Release(); }
public void AsyncOperationHandle_Release_DecrementsRefCount() { int expectedCount = 10; var op = new FakeTypedOperation(); AsyncOperationHandle <GameObject> typedHandle = new AsyncOperationHandle <GameObject>(op); AsyncOperationHandle <GameObject> validationHandle = new AsyncOperationHandle <GameObject>(op); IncreaseRefCount(typedHandle, expectedCount - 1); typedHandle.Release(); expectedCount--; var actualRefCount = DestructiveGetRefCount(validationHandle); Assert.AreEqual(expectedCount, actualRefCount); op = new FakeTypedOperation(); AsyncOperationHandle typelessHandle = new AsyncOperationHandle(op); AsyncOperationHandle typelessValidation = new AsyncOperationHandle(op); IncreaseRefCount(typelessHandle, expectedCount - 1); typelessHandle.Release(); expectedCount--; actualRefCount = DestructiveGetRefCount(typelessValidation); Assert.AreEqual(expectedCount, actualRefCount); }
public void ProvideInstance_CanProvide() { m_ResourceManager.ResourceProviders.Add(new GameObjectProvider()); ResourceLocationBase locDep = new ResourceLocationBase("prefab", "prefab1", "GOPRovider", typeof(UnityEngine.GameObject)); MockInstanceProvider iProvider = new MockInstanceProvider(); InstantiationParameters instantiationParameters = new InstantiationParameters(null, true); AsyncOperationHandle <GameObject>[] refResource = new AsyncOperationHandle <GameObject> [1]; iProvider.ProvideInstanceCallback = (rm, prefabHandle, iParam) => { refResource[0] = prefabHandle; Assert.AreEqual("prefab1", prefabHandle.Result.name); return(new GameObject("instance1")); }; iProvider.ReleaseInstanceCallback = (rm, go) => { rm.Release(refResource[0]); GameObject.Destroy(go); }; AsyncOperationHandle <GameObject> obj = m_ResourceManager.ProvideInstance(iProvider, locDep, instantiationParameters); m_ResourceManager.Update(0.0f); Assert.AreEqual(AsyncOperationStatus.Succeeded, obj.Status); Assert.AreEqual("instance1", obj.Result.name); Assert.AreEqual(1, m_ResourceManager.OperationCacheCount); obj.Release(); }
public IEnumerator CanUnloadAssetReference_WithAddressables() { yield return(Init()); AsyncOperationHandle handle = m_Addressables.Instantiate(AssetReferenceObjectKey); yield return(handle); Assert.IsNotNull(handle.Result as GameObject); AssetReferenceTestBehavior behavior = (handle.Result as GameObject).GetComponent <AssetReferenceTestBehavior>(); AsyncOperationHandle <GameObject> assetRefHandle = m_Addressables.Instantiate(behavior.Reference); yield return(assetRefHandle); Assert.IsNotNull(assetRefHandle.Result); string name = assetRefHandle.Result.name; Assert.IsNotNull(GameObject.Find(name)); m_Addressables.ReleaseInstance(assetRefHandle.Result); yield return(null); Assert.IsNull(GameObject.Find(name)); handle.Release(); }
public void ProvideResource_ReceiveDiagnosticsCallback_IGenericProviderOperationHasLocation() { m_Provider.ProvideCallback = (pi) => { pi.Complete(int.Parse(pi.Location.InternalId), true, null); }; m_RM.ResourceProviders.Add(m_Provider); List <ResourceManager.DiagnosticEventContext> eventsRecieved = new List <ResourceManager.DiagnosticEventContext>(); m_RM.RegisterDiagnosticCallback(ctx => { eventsRecieved.Add(ctx); }); var locations = new ResourceLocationBase("1", "1", m_Provider.ProviderId, typeof(object)); AsyncOperationHandle <object> op = m_RM.ProvideResource <object>(locations); m_RM.Update(0.0f); m_RM.ClearDiagnosticCallbacks(); for (int i = 0; i < eventsRecieved.Count; ++i) { if (eventsRecieved[i].OperationHandle.m_InternalOp is IGenericProviderOperation) { Assert.NotNull(eventsRecieved[i].Location); Assert.IsTrue(eventsRecieved[i].Location.InternalId == "1"); } } op.Release(); }
public IEnumerator AddressablesImpl_DownloadDependenciesAsync_CanDoWithChainKey() { // Setup if (TypeName == "BuildScriptFastMode" || TypeName == "BuildScriptVirtualMode") { Assert.Ignore($"Skipping test {nameof(AddressablesImpl_DownloadDependenciesAsync_CanDoWithChainKey)} for {TypeName}"); } yield return(Init()); string label = AddressablesTestUtility.GetPrefabLabel("BASE"); m_Addressables.hasStartedInitialization = false; AsyncOperationHandle op = m_Addressables.DownloadDependenciesAsync(label, false); m_Addressables.hasStartedInitialization = true; yield return(op); // Test var wrapOp = op.Convert <IList <IAssetBundleResource> >(); AssertDownloadDependencyBundlesAreValid(wrapOp); // Cleanup op.Release(); }
public IEnumerator AddressablesImpl_DownloadDependenciesAsync_CanDoWithChainOpHandle() { // Setup yield return(Init()); if (TypeName == "BuildScriptFastMode" || TypeName == "BuildScriptVirtualMode") { Assert.Ignore($"Skipping test {nameof(AddressablesImpl_DownloadDependenciesAsync_CanDoWithChainOpHandle)} for {TypeName}"); } IList <IResourceLocation> locations; var ret = m_Addressables.GetResourceLocations(new object[] { "prefabs_evenBASE" }, typeof(GameObject), Addressables.MergeMode.Intersection, out locations); Assert.IsTrue(ret); m_Addressables.hasStartedInitialization = false; AsyncOperationHandle op = m_Addressables.DownloadDependenciesAsync(locations, false); m_Addressables.hasStartedInitialization = true; yield return(op); // Test var wrapOp = op.Convert <IList <IAssetBundleResource> >(); AssertDownloadDependencyBundlesAreValid(wrapOp); // Cleanup op.Release(); }
public IEnumerator AddressablesImpl_DownloadDependenciesAsync_CanDownloadDependenciesWithChainFromObjectList() { // Setup yield return(Init()); if (TypeName == "BuildScriptFastMode" || TypeName == "BuildScriptVirtualMode") { Assert.Ignore($"Skipping test {nameof(AddressablesImpl_DownloadDependenciesAsync_CanDownloadDependenciesWithChainFromObjectList)} for {TypeName}"); } List <object> deps = new List <object>(); deps.Add(AddressablesTestUtility.GetPrefabLabel("BASE")); m_Addressables.hasStartedInitialization = false; AsyncOperationHandle op = m_Addressables.DownloadDependenciesAsync(deps, Addressables.MergeMode.Intersection, false); yield return(op); m_Addressables.hasStartedInitialization = true; // Test var wrapOp = op.Convert <IList <IAssetBundleResource> >(); AssertDownloadDependencyBundlesAreValid(wrapOp); // Cleanup op.Release(); }
public void WhenUWRIsUsed_CompletesSynchronously() { AsyncOperationHandle <GameObject> h = m_Addressables.LoadAssetAsync <GameObject>(GetForceUWRAddrName(0)); h.WaitForCompletion(); h.Release(); }
public IEnumerator CanGetResourceLocationsWithSingleKey() { yield return(Init()); int loadCount = 0; int loadedCount = 0; var ops = new List <AsyncOperationHandle <IList <IResourceLocation> > >(); foreach (var k in m_KeysHashSet) { loadCount++; AsyncOperationHandle <IList <IResourceLocation> > op = m_Addressables.LoadResourceLocations(k.Key); ops.Add(op); op.Completed += op2 => { loadedCount++; Assert.IsNotNull(op2.Result); Assert.AreEqual(k.Value, op2.Result.Count); }; } foreach (var op in ops) { yield return(op); op.Release(); } }
private void UnloadSceneCompleted(AsyncOperation obj) { if (m_sceneLoadHandle.IsValid()) { m_sceneLoadHandle.Release(); } Complete(m_Instance, true, ""); }
protected void ReleaseOp(AsyncOperationHandle handle) { if (handle.IsValid()) { handle.Release(); } Assert.IsFalse(handle.IsValid()); }
public IEnumerator WhenAssetBundleIsLocal_AndForceUWRIsDisabled_UWRIsNotUsed() { AsyncOperationHandle <GameObject> h = m_Addressables.LoadAssetAsync <GameObject>("testprefab"); Assert.AreEqual(0, WebRequestQueue.s_ActiveRequests.Count); yield return(h); h.Release(); }
public IEnumerator WhenAssetBundleIsLocal_AndForceUWRIsEnabled_UWRIsUsed() { AsyncOperationHandle <GameObject> h = m_Addressables.LoadAssetAsync <GameObject>(GetForceUWRAddrName(0)); Assert.AreEqual(1, WebRequestQueue.s_ActiveRequests.Count); yield return(h); h.Release(); }
protected override void Destroy() { //the scene will be unloaded via the UnloadSceneOp as it waits correctlyf or the unload to complete before releasing the load op if (m_DepOp.IsValid()) { m_DepOp.Release(); } base.Destroy(); }
protected override void Destroy() { SceneManager.UnloadSceneAsync(Result.Scene); if (m_DepOp.IsValid()) { m_DepOp.Release(); } base.Destroy(); }
public IEnumerator CanProvideMultipleResources() { AsyncOperationHandle <IList <GameObject> > op = m_ResourceManager.ProvideResources <GameObject>(m_Locations); yield return(op); Assert.AreEqual(op.Result.Count, m_Locations.Count); op.Release(); }
public void AsyncOperationHandle_ConvertToTyped_WithInvalidOpThrows() { var op = new FakeTypedOperation(); AsyncOperationHandle handle = new AsyncOperationHandle(op); AsyncOperationHandle handle2 = new AsyncOperationHandle(op); handle2.Release(); Assert.Throws <Exception>(() => { handle.Convert <GameObject>(); }); }
protected override void Execute() { if (m_sceneLoadHandle.IsValid()) { m_sceneLoadHandle.Release(); } else { Complete(m_Instance, true, ""); } }
public IEnumerator DownloadDependnecies_CanDownloadDependencies() { yield return(Init()); string label = AddressablesTestUtility.GetPrefabLabel("BASE"); AsyncOperationHandle op = m_Addressables.DownloadDependencies(label); yield return(op); op.Release(); }
public IEnumerator LoadAsset_WhenEntryDoesNotExist_OperationFails() { yield return(Init()); AsyncOperationHandle <GameObject> op = m_Addressables.LoadAsset <GameObject>("unknownlabel"); yield return(op); Assert.AreEqual(AsyncOperationStatus.Failed, op.Status); Assert.IsTrue(op.Result == null); op.Release(); }
public void ProvideResource_WhenDependencyFailsToLoad_AndProviderCannotLoadWithFailedDependencies_ProvideNotCalled() { m_Provider.ProvideCallback = (pi) => { throw new Exception("This Should Not Have Been Called"); }; m_RM.ResourceProviders.Add(m_Provider); ResourceLocationBase locDep = new ResourceLocationBase("depasset", "depasset", "unkonwn", typeof(object)); ResourceLocationBase locRoot = new ResourceLocationBase("rootasset", "rootasset", m_Provider.ProviderId, typeof(object), locDep); AsyncOperationHandle <object> op = m_RM.ProvideResource <object>(locRoot); m_RM.Update(0.0f); Assert.AreEqual(AsyncOperationStatus.Failed, op.Status); op.Release(); }
public void ProvideResource_ReceiveDiagnosticsCallback_CreateAndComplete() { m_Provider.ProvideCallback = (pi) => { pi.Complete(int.Parse(pi.Location.InternalId), true, null); }; m_RM.ResourceProviders.Add(m_Provider); List <ResourceManager.DiagnosticEventContext> eventsRecieved = new List <ResourceManager.DiagnosticEventContext>(); m_RM.RegisterDiagnosticCallback(ctx => { eventsRecieved.Add(ctx); }); var locations = new ResourceLocationBase("1", "1", m_Provider.ProviderId, typeof(object)); AsyncOperationHandle <object> op = m_RM.ProvideResource <object>(locations); m_RM.Update(0.0f); m_RM.ClearDiagnosticCallbacks(); bool created = false; bool completed = false; for (int i = 0; i < eventsRecieved.Count; ++i) { if (eventsRecieved[i].Type == ResourceManager.DiagnosticEventType.AsyncOperationCreate) { Assert.NotNull(eventsRecieved[i].Location); Assert.IsTrue(eventsRecieved[i].Location.InternalId == "1"); Assert.IsFalse(completed); Assert.IsFalse(created); created = true; } else if (eventsRecieved[i].Type == ResourceManager.DiagnosticEventType.AsyncOperationComplete) { Assert.NotNull(eventsRecieved[i].Location); Assert.True(eventsRecieved[i].Location.InternalId == "1"); Assert.IsFalse(completed); Assert.IsTrue(created); completed = true; } else if (eventsRecieved[i].Type == ResourceManager.DiagnosticEventType.AsyncOperationDestroy) { Assert.NotNull(eventsRecieved[i].Location); Assert.True(eventsRecieved[i].Location.InternalId == "1"); Assert.IsTrue(completed); Assert.IsTrue(created); } } op.Release(); }
public IEnumerator GetResourceLocationsWithCorrectKeyAndWrongTypeReturnsEmptyResult() { yield return(Init()); AsyncOperationHandle <IList <IResourceLocation> > op = m_Addressables.LoadResourceLocationsAsync("prefabs_evenBASE", typeof(Texture2D)); yield return(op); Assert.AreEqual(AsyncOperationStatus.Succeeded, op.Status); Assert.IsNotNull(op.Result); Assert.AreEqual(op.Result.Count, 0); op.Release(); }
public IEnumerator LoadAssetWithWrongType_WhenEntryExists_Fails() { yield return(Init()); string label = AddressablesTestUtility.GetPrefabUniqueLabel("BASE", 0); AsyncOperationHandle <Texture> op = m_Addressables.LoadAssetAsync <Texture>(label); yield return(op); Assert.AreEqual(AsyncOperationStatus.Failed, op.Status); Assert.IsNull(op.Result); op.Release(); }
public IEnumerator LoadAsset_WhenEntryExists_ReturnsAsset() { yield return(Init()); string label = AddressablesTestUtility.GetPrefabUniqueLabel("BASE", 0); AsyncOperationHandle <GameObject> op = m_Addressables.LoadAsset <GameObject>(label); yield return(op); Assert.AreEqual(AsyncOperationStatus.Succeeded, op.Status); Assert.IsTrue(op.Result != null); op.Release(); }
public IEnumerator LoadAsset_InvalidKeyThrowsInvalidKeyException() { //Setup yield return(Init()); //Test AsyncOperationHandle handle = default(AsyncOperationHandle); handle = m_Addressables.LoadAssetAsync <GameObject>("noSuchLabel"); Assert.AreEqual("Exception of type 'UnityEngine.AddressableAssets.InvalidKeyException' was thrown., Key=noSuchLabel", handle.OperationException.Message); yield return(handle); //Cleanup handle.Release(); }
public void ProvideResource_WhenDependencyFailsToLoad_AndProviderCanLoadWithFailedDependencies_ProviderStillProvides() { m_Provider._BehaviourFlags = ProviderBehaviourFlags.CanProvideWithFailedDependencies; m_Provider.ProvideCallback = (pi) => { pi.Complete(5, true, null); }; m_RM.ResourceProviders.Add(m_Provider); ResourceLocationBase locDep = new ResourceLocationBase("depasset", "depasset", "unkonwn", typeof(object)); ResourceLocationBase locRoot = new ResourceLocationBase("rootasset", "rootasset", m_Provider.ProviderId, typeof(object), locDep); AsyncOperationHandle <object> op = m_RM.ProvideResource <object>(locRoot); m_RM.Update(0.0f); Assert.AreEqual(AsyncOperationStatus.Succeeded, op.Status); Assert.AreEqual(5, op.Result); op.Release(); }