public async Task Query_ForInactiveElements_ReturnsInactive(string elementName)
        {
            // Act
            var mockQuery = new RemoteElementQuery(
                QueryFormat.NamedQuery, elementName, "Button");
            var query = await _agent.Query(mockQuery);

            // Assert
            Assert.IsFalse(query.IsActive, "Found object was not active.");
        }
        public async Task Query_ForNonexistentElements_ReturnsNullElements(string elementName)
        {
            // Act
            var mockQuery = new RemoteElementQuery(
                QueryFormat.NamedQuery, elementName, "Button");
            var query = await _agent.Query(mockQuery);

            // Assert
            Assert.AreEqual(String.Empty, query.Name);
            Assert.IsFalse(query.IsActive);
        }
        public async Task Query_ForActiveElements_ReturnsNamesAndActivity(string elementName)
        {
            // Act
            var mockQuery = new RemoteElementQuery(
                QueryFormat.NamedQuery, elementName, "Button");
            var query = await _agent.Query(mockQuery);

            // Assert
            Assert.AreEqual(elementName, query.Name, "Query returned wrong object.");
            Assert.IsTrue(query.IsActive, "Found object was not active.");
        }
        public void Query_WithSceneObjects_TaskResultHasSceneObjects()
        {
            // Arrange
            var remoteQuery = new RemoteElementQuery(
                QueryFormat.NamedQuery,
                "TestButton",
                "Button");

            // Act
            var foundElements = _agent.Query(remoteQuery).Result;

            // Assert
            Assert.IsNotNull(foundElements);
        }
        public async Task Query_TextElements_ReturnsTextContent(string elementName, string expectedText)
        {
            // Act
            var mockQuery = new RemoteElementQuery(
                QueryFormat.NamedQuery, elementName, "Text");
            var query = await _agent.Query(mockQuery);

            // Assert
            StringAssert.Contains(
                query.Text,
                expectedText,
                "Expected text is not found.");
            Assert.IsTrue(query.IsActive, "Found object was not active.");
        }
        public Task <RemoteUiElement> Query(RemoteElementQuery query)
        {
            ElementQuery nativeQuery;

            switch (query.Format)
            {
            case QueryFormat.NamedQuery:
                nativeQuery = new NamedElementQueryNative(query.Name);
                break;

            case QueryFormat.TypedQuery:
                var queryType = Type.GetType(query.TargetType);
                nativeQuery = string.IsNullOrEmpty(query.Name)
                    ? new TypedElementQueryNative(queryType)
                    : new TypedElementQueryNative(queryType, query.Name);
                break;

            case QueryFormat.PathQuery:
                nativeQuery = new PathElementQueryNative(query.Name);
                break;

            default:
                throw new ArgumentException("Element query format not known.");
            }

            var nativeResults = nativeQuery.Search();

            if (nativeResults != null)
            {
                var remoteResults = Enumerable.Select(
                    nativeResults, uie =>
                    new RemoteUiElement {
                    Name     = uie?.Name,
                    IsActive = uie?.IsActive ?? false,
                    Text     = uie?.Text,
                    XPos     = uie.LocalPosition.X,
                    YPos     = uie.LocalPosition.Y,
                    ZPos     = uie.LocalPosition.Z,
                    XRot     = uie.EulerRotation.X,
                    YRot     = uie.EulerRotation.Y,
                    ZRot     = uie.EulerRotation.Z,
                });

                return(Task.FromResult(remoteResults.FirstOrDefault()));
            }
            else
            {
                return(Task.FromResult <RemoteUiElement>(default));
        public async Task Query_RotatedElement_ReturnsRotation()
        {
            // Arrange
            const string EXPECTED_NAME     = "PositionedCube";
            Float3       EXPECTED_ROTATION = new Float3(25, 25, 25);

            // Act
            var mockQuery = new RemoteElementQuery(
                QueryFormat.NamedQuery, EXPECTED_NAME, "GameObject");
            var query = await _agent.Query(mockQuery);

            // Assert
            Assert.AreSame(EXPECTED_ROTATION.X, query.XRot);
            Assert.AreSame(EXPECTED_ROTATION.Y, query.YRot);
            Assert.AreSame(EXPECTED_ROTATION.Z, query.ZRot);
        }
        public async Task LeftClick_ClickableButton_IncrementsCounterText()
        {
            // Arrange
            const string ABOUT_BUTTON_NAME = "Clickable_Button";
            var          aboutButtonQuery  = new RemoteElementQuery(
                QueryFormat.NamedQuery, ABOUT_BUTTON_NAME, "Button");
            var aboutButtonElement = await _agent.Query(aboutButtonQuery);

            // Act
            _agent.LeftClick(aboutButtonElement);

            // Assert
            var aboutViewQuery = new RemoteElementQuery(
                QueryFormat.NamedQuery, "ClickableCounter_Text", "Text");
            var clickCounterText = await _agent.Query(aboutViewQuery);

            StringAssert.Contains(clickCounterText.Text, "1", "Counter did not increment.");
        }
 Task <AIR.UnityTestPilotRemote.Common.RemoteUiElement> Query(RemoteElementQuery query)
 {
     return(_service.Query(query));
 }
 public Task <RemoteUiElement> Query(RemoteElementQuery query) => _driver.Query(query);
Ejemplo n.º 11
0
 public Task <RemoteUiElement> Query(RemoteElementQuery queryArg)
 => _client.AskTask <RemoteUiElement>("Query", queryArg);