// Update is called once per frame void LateUpdate() { if (mActive && !particleSystem.IsAlive()) { PoolController.ReleaseAuto(transform); } }
// Code that runs on entering the state. public override void OnEnter() { #if POOLMANAGER Debug.LogError("Not implemented!"); #else Transform t = PoolController.Spawn(group.Value, type.Value, name.IsNone ? type.Value : name.Value, parent.Value == null ? null : parent.Value.transform); #endif if (t != null) { if (!toGameObject.IsNone) { toGameObject.Value = t.gameObject; } if (!position.IsNone) { t.position = position.Value; } } else { Debug.LogWarning("Unable to spawn: " + type.Value + " group: " + group.Value); } Finish(); }
public override void Setup() { pipeList = new List <AbstractControl>(); pipeLinkedList = new LinkedList <AbstractControl>(); for (int i = 0; i < 3; i++) { Vector3 pos; if (i == 0) { pos = new Vector3(gameView.localPosition.x + 40, gameView.localPosition.y + GetRandomLocalY()); } else { pos = new Vector3(gameView.localPosition.x + i * 40 + GetRandomLocalX(), gameView.localPosition.y + GetRandomLocalY()); } pipeControl = PoolController.Use(ControlPrefab, pos) as PipeControl; pipeControl.PipeOffScreen += OnPipeOffScreen; pipeLinkedList.AddLast(pipeControl); pipeList.Add(pipeControl); } if (!startGame) { StopPipe(); } }
public static HubTuple New(IListWindow window) { var pc = PoolController.Get(ListElementPool.Instance); var le = pc.Get<HubTuple>(window.TupleContainer.transform); le._Window = (AbstractWindow)window; return le; }
Projectile Fire() { if (chargeLevel < 0 || chargeLevel >= projectiles.Length) { return(null); } GameObject projectilePrefab = projectiles[chargeLevel]; if (projectilePrefab == null) { return(null); } GameObject go = PoolController.Activate(projectilePrefab, transform.position, transform.rotation); if (go != null) { // Successfully shot!!! energy = 0; chargeTimer.SetTime(chargeDelay); isCharging = false; AudioController.Instance.PlayOneShot(fireClip); return(go.GetComponent <Projectile>()); } else { return(null); } }
IEnumerator DoRelease() { bool kinematic = false; if (rigidbody) { kinematic = rigidbody.isKinematic; rigidbody.velocity = Vector3.zero; rigidbody.angularVelocity = Vector3.zero; rigidbody.isKinematic = true; } if (releaseDelay > 0) { yield return(new WaitForSeconds(releaseDelay)); } else { yield return(new WaitForFixedUpdate()); } transform.position = Vector3.zero; transform.rotation = Quaternion.identity; if (rigidbody) { rigidbody.isKinematic = kinematic; } PoolController.ReleaseAuto(transform); }
public void DropCoins() { int coinCount = Random.Range(coinsMin, coinsMax); for (int i = 0; i < coinCount; i++) { GameObject obj = poolYard.pool_item_Coin.GetPoolObject(); if (obj == null) { return; } obj.transform.position = transform.position + (Vector3)(Random.insideUnitCircle * lootDropRadius); obj.transform.rotation = transform.rotation; obj.SetActive(true); } if (DropsLoot) { PoolController theLootPool = lootTable[Random.Range(0, 3)]; GameObject obj; obj = theLootPool.GetPoolObject(); if (obj == null) { return; } obj.transform.position = transform.position + (Vector3)(Random.insideUnitCircle * lootDropRadius); obj.transform.rotation = transform.rotation; obj.SetActive(true); } }
public PoolController GetPoolController(Fsm fsm, bool createIfNotFound) { PoolController poolCtrl = null; switch (from) { case FromType.Owner: if (fsm == null) { return(null); } if (fsm.Owner == null) { return(null); } poolCtrl = fsm.Owner.GetComponent <PoolController>(); if (!poolCtrl && createIfNotFound) { poolCtrl = fsm.Owner.gameObject.AddComponent <PoolController>(); } break; case FromType.GameObject: if (gameObject == null) { return(null); } if (gameObject.IsNone || gameObject.Value == null) { return(null); } poolCtrl = gameObject.Value.GetComponent <PoolController>(); if (!poolCtrl && createIfNotFound) { poolCtrl = gameObject.Value.AddComponent <PoolController>(); } break; case FromType.Group: if (groupName == null) { return(null); } if (groupName.IsNone || string.IsNullOrEmpty(groupName.Value)) { return(null); } poolCtrl = PoolController.GetPool(groupName.Value); if (!poolCtrl && createIfNotFound) { poolCtrl = PoolController.CreatePool(groupName.Value); } break; } return(poolCtrl); }
void OnEntityStateChange(EntityBase ent) { if ((EntityState)ent.state == EntityState.Dead) { PoolController.Spawn(deathSpawnGroup, deathSpawnType, deathSpawnType, null, ent.transform.position, Quaternion.identity); } }
private void MakeInstance() { if (Instance == null) { Instance = this; } }
void Awake() { mInstance = this; mCtrl = GetComponent<PoolController>(); foreach(Group grp in groups) grp.ComputeItemRange(); }
public static ConsoleElement New(IListWindow window) { var pc = PoolController.Get(ListElementPool.Instance); var le = pc.Get <ConsoleElement>(window.TupleContainer.transform); le._Window = (AbstractWindow)window; return(le); }
private void Awake() { Instance = this; if (InitializeOnAwake) { Initialize(); } }
void OnLand(PlatformerController ctrl) { if (state != (int)EntityState.Invalid) { Vector2 p = transform.position; PoolController.Spawn("fxp", "landdust", "landdust", null, p); } }
public static Drone Load(SDrone data) { var d = PoolController.Get(ObjectPool.Instance).Get <Drone>(null, true); d.gameObject.SetActive(true); return(d.LoadState(data)); }
GameObject ShootAtPlayer() { GameObject spawnedObject = PoolController.Activate(objectToSpawn, transform.position, transform.rotation); Unit spawnedUnit = spawnedObject.GetComponent <Unit>(); spawnedUnit.TurnThisTowards(Player.Instance.transform.position); return(spawnedObject); }
public BaseProcedurePool() { m_poolCtrl = new PoolController(this); m_typeInfoDict = new Dictionary <string, MessageTypeInfo>(); m_typePairDict = new Dictionary <string, string>(); m_recvCallbackDict = new Dictionary <string, Action <object> >(); //m_sendFunctionDict = new Dictionary<string, Action<object>>(); }
void OnLanded(PlatformerController ctrl) { mJump = false; mLastJumpTime = Time.fixedTime; Vector2 p = transform.position; PoolController.Spawn("fxp", "landdust", "landdust", null, p); }
void Awake() { poolYard = GameObject.FindGameObjectWithTag("PoolYard").GetComponent <PoolYard>(); lootTable = new PoolController[] { poolYard.pool_item_Page, poolYard.pool_item_Potion, poolYard.pool_item_Attack }; }
public static NoFlyZone Load(SNoFlyZone data) { var nfz = PoolController.Get(ObjectPool.Instance).Get <NoFlyZone>(null, true); nfz.InPool = false; nfz._Data = new NFZData(data, nfz); SimManager.AllNFZ.Add(nfz.UID, nfz); return(nfz); }
public void ControllerPerformedSpecifiedNumberOfAttempts_ControllerStopsReattempting() { _controller = new PoolController<TestKey, TestResource>(_settings, _noObjectPoolMock.Object); _noObjectDirection.AttemptsNumber = 7; _controller.Obtain(_key, out _outPoolObject, _noObjectDirection); _noObjectPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, It.IsAny<Func<TestKey, TestResource>>()), Times.Exactly(7)); }
// Update is called once per frame void Update() { if (mSpawned && mActive) { if (!mAnimDat.isPlaying) { PoolController.ReleaseAuto(transform); } } }
public override void ReusePrefab() { AbstractControl lastearth = earthList[earthList.Count - 1]; Vector3 pos = new Vector2(lastearth.transform.localPosition.x + scalePref, lastearth.transform.localPosition.y); AbstractControl go = PoolController.Use(ControlPrefab, pos) as EarthControl; earthList.Add(go); earthList.Remove(earthList[earthList.Count - 1]); }
public override void ReusePrefab() { AbstractControl lastBgControl = backGroundList[backGroundList.Count - 1]; Vector3 pos = new Vector2(lastBgControl.transform.localPosition.x + scalePref, lastBgControl.transform.localPosition.y); AbstractControl go = PoolController.Use(ControlPrefab, pos) as BackgroundControl; backGroundList.Add(go); backGroundList.Remove(backGroundList[backGroundList.Count - 1]); }
public void AllAttemptsWereTriedAndPoolDidNotFindAvailableObject_ControllerReturnsDefault() { _controller = new PoolController<TestKey, TestResource>(_settings, _noObjectPoolMock.Object); _noObjectDirection.AttemptsNumber = 3; _noObjectDirection.OneIntervalBetweenAttemptsInSeconds = 0; var getStatus = _controller.Obtain(_key, out _outPoolObject, _noObjectDirection); Assert.That(getStatus, Is.False); Assert.That(_outPoolObject, Is.Null); }
private void Awake() { if (instance == null) { instance = this; } else { Destroy(gameObject); } }
void Awake() { mInstance = this; mCtrl = GetComponent <PoolController>(); foreach (Group grp in groups) { grp.ComputeItemRange(); } }
void OnBuddyHPChange(Stats aStat, float delta) { int deadInd = -1; int stunInd = -1; for (int i = 0; i < mBuddyStats.Length; i++) { if (mBuddyStats[i] == aStat) { if (aStat.lastDamageSource && aStat.lastDamageSource.stun) { stunInd = i; } if (aStat.curHP <= 0) { deadInd = i; mNumDead++; } } } if (deadInd != -1) { buddies[deadInd].SetActive(false); Vector3 pt = buddies[deadInd].collider.bounds.center; pt.z = 0.0f; PoolController.Spawn(deathSpawnGroup, mDeathSpawnType, mDeathSpawnType, null, pt, Quaternion.identity); } projectile.SetActive(mNumDead == 0); if (mNumDead == mBuddyStats.Length) { state = (int)EntityState.Dead; } else { if (deadInd != -1) { for (int i = 0; i < mBuddyAnims.Length; i++) { if (i != deadInd) { mBuddyAnims[i].Play("sad"); } } } else if (stunInd != -1) { state = (int)EntityState.Stun; } } }
public void Start() { res = GameObject.FindObjectOfType <PlayerResources>(); StartCoroutine("Cooldown"); // Handle visuals GameObject.FindObjectOfType <WeaponVisController>().AddWeapon(weaponType); pool = GameObject.FindObjectOfType <PoolController>(); }
public override void ReusePrefab() { AbstractControl lastPipe = pipeList[pipeList.Count - 1]; Vector3 pos = new Vector2(lastPipe.transform.localPosition.x + GetRandomLocalX(), gameView.transform.localPosition.y + GetRandomLocalY()); AbstractControl go = PoolController.Use(ControlPrefab, pos) as PipeControl; pipeList.Add(go); pipeList.Remove(pipeList[pipeList.Count - 1]); pipeLinkedList.AddLast(go); }
public void OpenInfoWindow() { if (InfoWindow == null) { InfoWindow = PoolController.Get(WindowPool.Instance).Get <JobWindow>(UIManager.Transform); InfoWindow.Source = this; } else { InfoWindow.transform.SetAsLastSibling(); } }
public static Hub Load(SHub data, List <SDrone> drones, List <SBattery> batteries) { Hub hub = PoolController.Get(ObjectPool.Instance).Get <Hub>(null, true); hub.transform.position = data.position; hub.transform.SetParent(null); hub.gameObject.SetActive(true); hub.InPool = false; SimManager.AllHubs.Add(hub.UID, hub); hub._Data = new HubData(data, hub, drones, batteries); return(hub); }
public virtual GameObject Spawn(Quaternion spawnRotation) { Unit _unit = objectToSpawn.GetComponent <Unit>(); if (_unit != null) { return(PoolController.Activate(objectToSpawn, transform.position, spawnRotation)); } else { Debug.LogError("[UnitSpawner] objectToSpawn is not a Unit!"); return(null); } }
void Start() { Obstacle = (GameObject)Resources.Load("Prefabs/Obstacle"); GameController = Instantiate((GameObject) Resources.Load("Prefabs/GameController")); ObstacleGen = Instantiate((GameObject)Resources.Load("Prefabs/ObstacleGenerator")); pool = GameController.GetComponent<PoolController>(); obstacleGenerator = ObstacleGen.GetComponent<ObstacleGenerator>(); pool.setObstacles(Obstacle); obstacleGenerator.setPoolController(pool); pool.enabled = true; obstacleGenerator.enabled = true; }
public ThreadPool(ThreadPoolSettings settings, IThreadPoolTaskResultNotifier taskResultNotifier = null) { _settings = settings; _taskResultNotifier = taskResultNotifier; _poolController = CreateThreadPoolControllerInstance(); _noIdleWorkerDirection = new DirectionIfNoObjectIsAvailable<int, ThreadWorker> { CreateDelegateIfNoObjectIsAvailable = CreateWorker, AttemptsNumber = _settings.WaitingSettings != null ? _settings.WaitingSettings.WaitingsNumber + 1 : 1, OneIntervalBetweenAttemptsInSeconds = _settings.WaitingSettings != null ? _settings.WaitingSettings.OneWaitingTimespanInSeconds : 0, }; _managerThread = new Thread(AssignTasksToWorkers) { Name = ConfigurationManager.AppSettings["managerThreadName"], IsBackground = true, }; _managerThread.Start(); }
public void ReleaseWasCalled_ControllerForgotsObjectToKeyMapping() { _settings.CallingReleaseOperationWillHappen = true; _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); _controller.Obtain(_key, out _outPoolObject, null); _controller.Release(_outPoolObject); Assert.That(_controller.ObtainedObjectToItsKey.Count, Is.EqualTo(0)); }
public void ReleasingOfNotObtainedObject_DetailedExceptionIsThrown() { _settings.CallingReleaseOperationWillHappen = true; _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); var resource = new TestResource(string.Empty); var hintException = Assert.Throws<InvalidPoolOperationException<TestKey, TestResource>>( () => _controller.Release(resource)); Assert.That(hintException.Message, Is.EqualTo("Only obtained objects are allowed to be released")); Assert.That(hintException.Key, Is.Null); Assert.That(hintException.Object, Is.EqualTo(resource)); }
public void ReleaseWasCalled_PoolIsCalled() { _settings.CallingReleaseOperationWillHappen = true; _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); TestResource outResource1; TestResource outResource2; TestResource outResource3; var key1 = new TestKey { Identifier = 100 }; var key2 = new TestKey { Identifier = 200 }; _controller.Obtain(key1, out outResource1, null); _controller.Obtain(key1, out outResource2, null); _controller.Obtain(key2, out outResource3, null); _controller.Release(outResource1); _controller.Release(outResource2); _controller.Release(outResource3); _successPoolMock.Verify(x => x.Release(key1, outResource1), Times.Once); _successPoolMock.Verify(x => x.Release(key1, outResource2), Times.Once); _successPoolMock.Verify(x => x.Release(key2, outResource3), Times.Once); }
public void setPoolController(PoolController pool) { this.pool = pool; }
public void ObtainWasCalled_PoolIsCalled_ProvidedObjectIsReturned() { _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); var getStatus = _controller.Obtain(_key, out _outPoolObject, null); Assert.That(getStatus, Is.True); Assert.That(_outPoolObject.Value, Is.EqualTo(_key.Identifier + " 1")); _successPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, null), Times.Once); }
public void ReleasingWasNotPromised_ControllerIgnoresDirectionToWaitAndOrderPoolToCreateNewObject() { _settings.CallingReleaseOperationWillHappen = false; _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); Func<TestKey, TestResource> createDelegate = key => new TestResource(Mocks.Pool.ResourceValueAfterWaitings); var directionToWaitForAvailableObject = new DirectionIfNoObjectIsAvailable<TestKey, TestResource> { AttemptsNumber = 5, OneIntervalBetweenAttemptsInSeconds = 10, CreateDelegateIfNoObjectIsAvailable = createDelegate, }; _controller.Obtain(_key, out _outPoolObject, directionToWaitForAvailableObject); _successPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, createDelegate), Times.Once); _successPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, null), Times.Never); }
public void ReleasingWasNotPromised_ControllerDoesNotRememberObtainedObjects() { _settings.CallingReleaseOperationWillHappen = false; _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); _controller.Obtain(_key, out _outPoolObject, null); Assert.That(_controller.ObtainedObjectToItsKey.Count, Is.EqualTo(0)); }
public void ReleasingWasPromised_ControllerCanRecallKeyForEachObtainedValue() { _settings.CallingReleaseOperationWillHappen = true; _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); TestResource outResource1; TestResource outResource2; TestResource outResource3; var key1 = new TestKey { Identifier = 100 }; var key2 = new TestKey { Identifier = 200 }; _controller.Obtain(key1, out outResource1, null); _controller.Obtain(key1, out outResource2, null); _controller.Obtain(key2, out outResource3, null); Assert.That(_controller.ObtainedObjectToItsKey[outResource1], Is.EqualTo(key1)); Assert.That(_controller.ObtainedObjectToItsKey[outResource2], Is.EqualTo(key1)); Assert.That(_controller.ObtainedObjectToItsKey[outResource3], Is.EqualTo(key2)); }
public void CreateDelegateIsSpecified_PoolIsCalledWithIt_ButOnlyLastTime() { Func<TestKey, TestResource> createDelegate = key => new TestResource("on fifth call"); int curCallNumber = 0; TestResource orderControllingOutResource; var callsOrderControllingPoolMock = new Mock<IPool<TestKey, TestResource>>(MockBehavior.Strict); callsOrderControllingPoolMock.Setup(x => x.TryObtain(_key, out orderControllingOutResource, null)) .Returns(false) .Callback(() => Assert.That(++curCallNumber, Is.InRange(1, 4))); callsOrderControllingPoolMock.Setup(x => x.TryObtain(_key, out orderControllingOutResource, createDelegate)) .OutCallback((TestKey key, out TestResource outResource, Func<TestKey,TestResource> createDel) => outResource = createDelegate(key)) .Returns<TestKey, TestResource, Func<TestKey, TestResource>>((key, outResource, createDel) => true) .Callback(() => Assert.That(++curCallNumber, Is.EqualTo(5))); _controller = new PoolController<TestKey, TestResource>(_settings, callsOrderControllingPoolMock.Object); _noObjectDirection.AttemptsNumber = 5; _noObjectDirection.CreateDelegateIfNoObjectIsAvailable = createDelegate; var getStatus = _controller.Obtain(_key, out _outPoolObject, _noObjectDirection); Assert.That(getStatus, Is.True); Assert.That(_outPoolObject.Value, Is.EqualTo("on fifth call")); callsOrderControllingPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, null), Times.Exactly(4)); callsOrderControllingPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, createDelegate), Times.Once); callsOrderControllingPoolMock.Verify(x => x.TryObtain(It.IsAny<TestKey>(), out _outPoolObject, It.IsAny<Func<TestKey, TestResource>>()), Times.Exactly(5)); }
private PoolController<int, ThreadWorker> CreateThreadPoolControllerInstance() { var workerActions = new ObjectActionsBasedOnDelegateOrInterface<ThreadWorker>(new ExplicitlyDefinedObjectActions<ThreadWorker>()); var objectUtilizer = new ObjectUtilizer<int, ThreadWorker>(); var basicPoolSettings = new PoolItemsStorageSettings { AllowOnlyOneUserPerObject = true, BalancingStrategy = _settings.BalancingStrategy, MaxObjectsCountPerKey = _settings.MaxWorkersCount, ThrowIfCantCreateObjectBecauseOfReachedLimit = false, }; var basicPool = new PoolItemsStorage<int, ThreadWorker>(basicPoolSettings, workerActions, objectUtilizer); var stateMonitoringSettings = new PWObjectStateMonitoringSettings { MaxObjectIdleTimeSpanInSeconds = _settings.MaxObjectIdleTimeSpanInSeconds, MaxObjectLifetimeInSeconds = _settings.MaxObjectIdleTimeSpanInSeconds, TimeSpanBetweenRevivalsInSeconds = _settings.MonitorTimeSpanInSeconds, }; var stateMonitoringPool = new PWObjectStateMonitoringWrapper<int, ThreadWorker>(stateMonitoringSettings, basicPool, workerActions, objectUtilizer); var singleUsePool = new PWSingleUseEnforcingWrapper<int, ThreadWorker>(stateMonitoringPool); var autoReleasingPool = new PWAutoReleasingWrapper<int, ThreadWorker>(singleUsePool); var poolControllerSettings = new PoolControllerSettings { CallingReleaseOperationWillHappen = true, }; var controller = new PoolController<int, ThreadWorker>(poolControllerSettings, autoReleasingPool); autoReleasingPool.SetPoolController(controller); return controller; }
public void NullNoObjectDirection_ControllerPerformsOneAttemptsWithoutCreateDelegate() { _controller = new PoolController<TestKey, TestResource>(_settings, _noObjectPoolMock.Object); _controller.Obtain(_key, out _outPoolObject, null); _noObjectPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, null), Times.Once); }
public void ReattempsIntervalIsSpecified_ControllerWaitsBeforeReattempt() { _controller = new PoolController<TestKey, TestResource>(_settings, _noObjectThreeTimesPoolMock.Object); _noObjectDirection.AttemptsNumber = 8; _noObjectDirection.OneIntervalBetweenAttemptsInSeconds = 1; var stopwatch = Stopwatch.StartNew(); var getStatus = _controller.Obtain(_key, out _outPoolObject, _noObjectDirection); stopwatch.Stop(); Assert.That(stopwatch.ElapsedMilliseconds, Is.InRange(2900, 4000)); Assert.That(getStatus, Is.True); Assert.That(_outPoolObject.Value, Is.EqualTo(Mocks.Pool.ResourceValueAfterWaitings)); }
public void NumberOfAttemptsIsSpecified_PoolIsRecalledAndFinalResultIsGood() { _controller = new PoolController<TestKey, TestResource>(_settings, _noObjectThreeTimesPoolMock.Object); _noObjectDirection.AttemptsNumber = 5; var getStatus = _controller.Obtain(_key, out _outPoolObject, _noObjectDirection); Assert.That(getStatus, Is.True); Assert.That(_outPoolObject.Value, Is.EqualTo(Mocks.Pool.ResourceValueAfterWaitings)); _noObjectThreeTimesPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, null), Times.Exactly(4)); }
public void PoolThrew_ControllerStopsReattemptingAndThrowDetailedPoolException() { _controller = new PoolController<TestKey, TestResource>(_settings, _throwingPoolMock.Object); _noObjectDirection.AttemptsNumber = 3; var internalErrorException = Assert.Throws<PoolException<TestKey>>(() => _controller.Obtain(_key, out _outPoolObject, _noObjectDirection)); var expectedMessage = string.Format("Something failed during attempt #1 of obtaining object with key='{0}'. " + "Look at inner exception for details", _key); Assert.That(internalErrorException.Message, Is.EqualTo(expectedMessage)); Assert.That(internalErrorException.Key, Is.EqualTo(_key)); Assert.That(internalErrorException.InnerException, Is.TypeOf<ObjectCreationFailedException<TestKey, TestResource>>()); _throwingPoolMock.Verify(x => x.TryObtain(_key, out _outPoolObject, null), Times.Once); }
public void ReleasingWasNotPromisedAndPoolThrew_AttemptsNumberInExceptionIsEqualToOne() { _settings.CallingReleaseOperationWillHappen = false; _controller = new PoolController<TestKey, TestResource>(_settings, _throwingPoolMock.Object); _noObjectDirection.AttemptsNumber = 8; _noObjectDirection.OneIntervalBetweenAttemptsInSeconds = 0; var internalErrorException = Assert.Throws<PoolException<TestKey>>(() => _controller.Obtain(_key, out _outPoolObject, _noObjectDirection)); var expectedMessage = string.Format("Something failed during attempt #1 of obtaining object with key='{0}'. " + "Look at inner exception for details", _key); Assert.That(internalErrorException.Message, Is.EqualTo(expectedMessage)); }
public void ReleasingWasNotPromisedButWasCalled_ExceptionWithHintToPromiseReleasingIsThrown() { _settings.CallingReleaseOperationWillHappen = false; _controller = new PoolController<TestKey, TestResource>(_settings, _successPoolMock.Object); var resource = new TestResource(string.Empty); var hintException = Assert.Throws<InvalidPoolOperationException<TestKey, TestResource>>( () => _controller.Release(resource)); var expectedMessage = "In order to release objects promise it by setting " + "PoolControllerSettings.CallingReleaseOperationWillHappen to " + "true. Currently it's false"; Assert.That(hintException.Message, Is.EqualTo(expectedMessage)); Assert.That(hintException.Key, Is.Null); Assert.That(hintException.Object, Is.EqualTo(resource)); }