fuchsia/engine/browser/ax_tree_converter_unittest.cc

// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "fuchsia/engine/browser/ax_tree_converter.h"

#include <lib/ui/scenic/cpp/commands.h>
#include <vector>

#include "testing/gtest/include/gtest/gtest.h"
#include "ui/gfx/transform.h"

using fuchsia::accessibility::semantics::Action;
using fuchsia::accessibility::semantics::Attributes;
using fuchsia::accessibility::semantics::Node;
using fuchsia::accessibility::semantics::Role;

namespace {

const char kLabel1[] = "label nodes, not people";
const char kLabel2[] = "fancy stickers";
const int32_t kChildId1 = 23901;
const int32_t kChildId2 = 484345;
const int32_t kChildId3 = 4156877;
const int32_t kRectX = 1;
const int32_t kRectY = 2;
const int32_t kRectWidth = 7;
const int32_t kRectHeight = 8;
const std::array<float, 16> k4DIdentityMatrix = {1, 0, 0, 0, 0, 1, 0, 0,
                                                 0, 0, 1, 0, 0, 0, 0, 1};

bool SemanticNodesAreEqual(const Node& first, const Node& second) {
  if (first.node_id() != second.node_id())
    return false;
  if (first.has_role() && second.has_role() && first.role() != second.role()) {
    return false;
  }
  if (first.has_attributes() && second.has_attributes() &&
      first.attributes().label() != second.attributes().label()) {
    return false;
  }
  if (first.has_actions() && second.has_actions() &&
      first.actions() != second.actions()) {
    return false;
  }
  if (first.has_child_ids() && second.has_child_ids() &&
      first.child_ids() != second.child_ids()) {
    return false;
  }
  if (first.has_location() && second.has_location()) {
    if (first.location().min.x != second.location().min.x)
      return false;
    if (first.location().min.y != second.location().min.y)
      return false;
    if (first.location().min.z != second.location().min.z)
      return false;
    if (first.location().max.x != second.location().max.x)
      return false;
    if (first.location().max.y != second.location().max.y)
      return false;
    if (first.location().max.z != second.location().max.z)
      return false;
  }
  if (first.has_transform() && second.has_transform() &&
      first.transform().matrix != second.transform().matrix) {
    return false;
  }

  return true;
}

ui::AXNodeData CreateAXNodeData(ax::mojom::Role role,
                                uint32_t actions,
                                std::vector<int32_t> child_ids,
                                ui::AXRelativeBounds relative_bounds,
                                base::StringPiece name) {
  ui::AXNodeData node;
  node.role = role;
  node.actions = actions;
  node.child_ids = child_ids;
  node.relative_bounds = relative_bounds;
  if (!name.empty())
    node.AddStringAttribute(ax::mojom::StringAttribute::kName, name.data());
  return node;
}

Node CreateSemanticNode(uint32_t id,
                        Role role,
                        Attributes attributes,
                        std::vector<Action> actions,
                        std::vector<uint32_t> child_ids,
                        fuchsia::ui::gfx::BoundingBox location,
                        fuchsia::ui::gfx::mat4 transform) {
  Node node;
  node.set_node_id(id);
  node.set_role(role);
  node.set_attributes(std::move(attributes));
  node.set_actions(actions);
  node.set_child_ids(child_ids);
  node.set_location(location);
  node.set_transform(transform);
  return node;
}

class AXTreeConverterTest : public testing::Test {
 public:
  AXTreeConverterTest() = default;
  ~AXTreeConverterTest() override = default;

  DISALLOW_COPY_AND_ASSIGN(AXTreeConverterTest);
};

TEST_F(AXTreeConverterTest, AllFieldsSetAndEqual) {
  ui::AXRelativeBounds relative_bounds = ui::AXRelativeBounds();
  relative_bounds.bounds = gfx::RectF(kRectX, kRectY, kRectWidth, kRectHeight);
  relative_bounds.transform =
      std::make_unique<gfx::Transform>(gfx::Transform::kSkipInitialization);
  relative_bounds.transform->MakeIdentity();
  auto source_node_data =
      CreateAXNodeData(ax::mojom::Role::kButton,
                       static_cast<uint32_t>(ax::mojom::Action::kDoDefault),
                       std::vector<int32_t>{kChildId1, kChildId2, kChildId3},
                       relative_bounds, kLabel1);
  auto converted_node = AXNodeDataToSemanticNode(source_node_data);
  EXPECT_EQ(static_cast<uint32_t>(source_node_data.id),
            converted_node.node_id());

  Attributes attributes;
  attributes.set_label(kLabel1);
  fuchsia::ui::gfx::BoundingBox box;
  box.min = scenic::NewVector3({kRectX, kRectY + kRectHeight, 0.0f});
  box.max = scenic::NewVector3({kRectHeight, kRectY, 0.0f});
  fuchsia::ui::gfx::Matrix4Value mat =
      scenic::NewMatrix4Value(k4DIdentityMatrix);
  auto expected_node = CreateSemanticNode(
      source_node_data.id, Role::UNKNOWN, std::move(attributes),
      std::vector<Action>{Action::DEFAULT},
      std::vector<uint32_t>{kChildId1, kChildId2, kChildId3}, box, mat.value);

  EXPECT_TRUE(SemanticNodesAreEqual(std::move(converted_node),
                                    std::move(expected_node)));
}

TEST_F(AXTreeConverterTest, SomeFieldsSetAndEqual) {
  ui::AXNodeData source_node_data;
  source_node_data.actions =
      static_cast<uint32_t>(ax::mojom::Action::kDoDefault);
  source_node_data.child_ids = std::vector<int32_t>{kChildId1};
  auto converted_node = AXNodeDataToSemanticNode(source_node_data);
  EXPECT_EQ(static_cast<uint32_t>(source_node_data.id),
            converted_node.node_id());

  Node expected_node;
  expected_node.set_node_id(source_node_data.id);
  expected_node.set_actions(std::vector<Action>{Action::DEFAULT});
  expected_node.set_child_ids(std::vector<uint32_t>{kChildId1});

  EXPECT_TRUE(SemanticNodesAreEqual(std::move(converted_node),
                                    std::move(expected_node)));
}

TEST_F(AXTreeConverterTest, FieldMismatch) {
  ui::AXRelativeBounds relative_bounds = ui::AXRelativeBounds();
  relative_bounds.bounds = gfx::RectF(kRectX, kRectY, kRectWidth, kRectHeight);
  relative_bounds.transform =
      std::make_unique<gfx::Transform>(gfx::Transform::kSkipInitialization);
  relative_bounds.transform->MakeIdentity();
  auto source_node_data =
      CreateAXNodeData(ax::mojom::Role::kButton,
                       static_cast<uint32_t>(ax::mojom::Action::kDoDefault),
                       std::vector<int32_t>{kChildId1, kChildId2, kChildId3},
                       relative_bounds, kLabel1);
  auto converted_node = AXNodeDataToSemanticNode(source_node_data);
  EXPECT_EQ(static_cast<uint32_t>(source_node_data.id),
            converted_node.node_id());

  Attributes attributes;
  attributes.set_label(kLabel1);
  fuchsia::ui::gfx::BoundingBox box;
  std::array<float, 3> min = {kRectX, kRectY + kRectHeight, 0.0f};
  std::array<float, 3> max = {kRectHeight, kRectY, 0.0f};
  box.min = scenic::NewVector3(min);
  box.max = scenic::NewVector3(max);
  fuchsia::ui::gfx::Matrix4Value mat =
      scenic::NewMatrix4Value(k4DIdentityMatrix);
  auto expected_node = CreateSemanticNode(
      source_node_data.id, Role::UNKNOWN, std::move(attributes),
      std::vector<Action>{Action::DEFAULT},
      std::vector<uint32_t>{kChildId1, kChildId2, kChildId3}, box, mat.value);

  // Start with nodes being equal.
  EXPECT_TRUE(SemanticNodesAreEqual(converted_node, expected_node));

  // Make a copy of |source_node_data| and change the name attribute. Check that
  // the resulting |converted_node| is different from |expected_node|.
  auto modified_node_data = source_node_data;
  modified_node_data.AddStringAttribute(ax::mojom::StringAttribute::kName,
                                        kLabel2);
  converted_node = AXNodeDataToSemanticNode(modified_node_data);
  EXPECT_FALSE(SemanticNodesAreEqual(converted_node, expected_node));

  // The same as above, this time changing |child_ids|.
  modified_node_data = source_node_data;
  modified_node_data.child_ids = std::vector<int32_t>{};
  converted_node = AXNodeDataToSemanticNode(modified_node_data);
  EXPECT_FALSE(SemanticNodesAreEqual(converted_node, expected_node));
}

}  // namespace