Function ASSERT_OK_AND_ASSIGN

common/navigable_ast_test.cc:241–369

TEST(NavigableAst, ParentRelationCreateList) {
  ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("[123]"));

  NavigableAst ast = NavigableAst::Build(parsed_expr->root_expr());
  const NavigableAstNode& root = ast.Root();

  EXPECT_EQ(root.node_kind(), NodeKind::kList);
  ASSERT_THAT(root.children(), SizeIs(1));
  const auto* child = root.children()[0];

  EXPECT_EQ(child->parent_relation(), ChildKind::kListElem);
  EXPECT_EQ(child->node_kind(), NodeKind::kConstant);
}

TEST(NavigableAst, ParentRelationComprehension) {
  ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("[1].all(x, x < 2)"));

  NavigableAst ast = NavigableAst::Build(parsed_expr->root_expr());
  const NavigableAstNode& root = ast.Root();

  EXPECT_EQ(root.node_kind(), NodeKind::kComprehension);
  ASSERT_THAT(root.children(), SizeIs(5));
  const auto* range = root.children()[0];
  const auto* init = root.children()[1];
  const auto* condition = root.children()[2];
  const auto* step = root.children()[3];
  const auto* finish = root.children()[4];

  EXPECT_EQ(range->parent_relation(), ChildKind::kComprehensionRange);
  EXPECT_EQ(init->parent_relation(), ChildKind::kComprehensionInit);
  EXPECT_EQ(condition->parent_relation(), ChildKind::kComprehensionCondition);
  EXPECT_EQ(step->parent_relation(), ChildKind::kComprehensionLoopStep);
  EXPECT_EQ(finish->parent_relation(), ChildKind::kComprensionResult);
}

TEST(NavigableAst, DescendantsPostorder) {
  ASSERT_OK_AND_ASSIGN(auto parsed_expr, Parse("1 + (x * 3)"));

  NavigableAst ast = NavigableAst::Build(parsed_expr->root_expr());
  const NavigableAstNode& root = ast.Root();

  EXPECT_EQ(root.node_kind(), NodeKind::kCall);

  std::vector<int> constants;
  std::vector<NodeKind> node_kinds;

  for (const NavigableAstNode& node : root.DescendantsPostorder()) {
    if (node.node_kind() == NodeKind::kConstant) {
      constants.push_back(node.expr()->const_expr().int64_value());
    }
    node_kinds.push_back(node.node_kind());
  }

  EXPECT_THAT(node_kinds, ElementsAre(NodeKind::kConstant, NodeKind::kIdent,
                                      NodeKind::kConstant, NodeKind::kCall,
                                      NodeKind::kCall));
  EXPECT_THAT(constants, ElementsAre(1, 3));
}