public async Task Until_LateElementCreation_ElementFound()
        {
            // Arrange
            var          timeout = TimeSpan.FromSeconds(TIMEOUT_SECONDS + 1);
            const string DELAY_COUNTER_TEXT_NAME = "Delayed_Counter_Text";
            var          textQuery = _driver.FindElement(By.Name(DELAY_COUNTER_TEXT_NAME));

            var currentText    = textQuery.Text;
            var text           = currentText.Split(new [] { ' ' }).Last();
            var currentCounter = int.Parse(text);

            // Act
            const string DELAY_COUNTER_BUTTON_NAME = "Delayed_Counter_Button";
            var          buttonQuery = _driver.FindElement(By.Name(DELAY_COUNTER_BUTTON_NAME));

            buttonQuery.LeftClick();

            const string EXPECTED_EFFECT_TEXT_NAME = "DelayedEffect_Text_{0}";
            var          nameString       = string.Format(EXPECTED_EFFECT_TEXT_NAME, currentCounter + 1);
            var          wait             = new UnityDriverWait(_driver, timeout);
            var          expectedTextName = await wait.Until(d => d.FindElement(By.Type <Text>(nameString)));

            // Assert
            Assert.IsTrue(expectedTextName.IsActive, nameString + " not found.");
        }
        public async Task Until_ElementExists_FindsNextFrame()
        {
            // Arrange
            const string SEARCHABLE_TEXT_NAME = "Searchable_Text";
            var          timeout = TimeSpan.FromSeconds(TIMEOUT_SECONDS);

            // Act
            var wait             = new UnityDriverWait(_driver, timeout);
            var expectedTextName = await wait.Until(d =>
                                                    d.FindElement(By.Type <Text>(SEARCHABLE_TEXT_NAME)));

            // Assert
            Assert.IsTrue(expectedTextName.IsActive);
        }
Ejemplo n.º 3
0
    public IEnumerator Until_MissingElement_TimesOut()
    {
        // Arrange
        const int TIMEOUT   = 1;
        float     startTime = Time.time;
        var       wait      = new UnityDriverWait(_driver, TimeSpan.FromSeconds(TIMEOUT));

        // Act
        yield return(wait.Until(
                         d => null,
                         (e) => { }
                         ));

        // Assert
        Assert.Greater(Time.time, startTime + TIMEOUT);
    }
        public async Task Until_MissingElement_TimesOut()
        {
            // Arrange
            const string SEARCHABLE_TEXT_NAME = "NotActuallyInScene_Text";
            var          timeoutSpan          = TimeSpan.FromSeconds(TIMEOUT_SECONDS);
            var          endTime = DateTime.Now + timeoutSpan;

            // Act
            var wait = new UnityDriverWait(_driver, timeoutSpan);
            await wait.Until(d =>
                             d.FindElement(By.Type <Text>(SEARCHABLE_TEXT_NAME)));

            // Assert
            Assert.IsTrue(
                DateTime.Now >= endTime,
                "Test finished before timeout.");
        }
Ejemplo n.º 5
0
    public IEnumerator Until_ElementExists_FindsNextFrame()
    {
        // Arrange
        _testGo = new GameObject(TEST_GO_NAME);
        yield return(null);

        const int NEXT_FRAME = 1;
        UiElement element    = null;
        var       startFrame = Time.frameCount;
        var       wait       = new UnityDriverWait(_driver, TimeSpan.FromSeconds(1f));

        // Act
        yield return(wait.Until(
                         d => d.FindElement(By.Name(TEST_GO_NAME)),
                         (v) => element = v
                         ));

        // Assert
        Assert.IsNotNull(element);
        Assert.AreEqual(startFrame + NEXT_FRAME, Time.frameCount);
    }
Ejemplo n.º 6
0
        public IEnumerator Until_LateElementCreation_ElementFound()
        {
            // Arrange
            var       startTime = Time.time;
            const int TIMEOUT = 2, TEST_DELAY = 1;

            Coroutiner.StartCoroutine(DelayedSpawnGO(TEST_GO_NAME, TEST_DELAY));
            UiElement element = null;
            var       wait    = new UnityDriverWait(_driver, TimeSpan.FromSeconds(TIMEOUT));

            // Act
            yield return(wait.Until(d =>
                                    d.FindElement(By.Name(TEST_GO_NAME)),
                                    (e) => element = e
                                    ));

            // Assert
            Assert.IsNotNull(element);
            Assert.Less(Time.time, startTime + TIMEOUT);
            Assert.Greater(Time.time, startTime);
            Assert.GreaterOrEqual(Time.time, startTime + TEST_DELAY);
        }