/*
 * Copyright 2014 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "cobalt/css_parser/parser.h"

#include <cmath>
#include <string>
#include <vector>

#include "base/bind.h"
#include "cobalt/cssom/active_pseudo_class.h"
#include "cobalt/cssom/after_pseudo_element.h"
#include "cobalt/cssom/before_pseudo_element.h"
#include "cobalt/cssom/child_combinator.h"
#include "cobalt/cssom/class_selector.h"
#include "cobalt/cssom/complex_selector.h"
#include "cobalt/cssom/compound_selector.h"
#include "cobalt/cssom/css_declared_style_data.h"
#include "cobalt/cssom/css_font_face_declaration_data.h"
#include "cobalt/cssom/css_font_face_rule.h"
#include "cobalt/cssom/css_keyframe_rule.h"
#include "cobalt/cssom/css_keyframes_rule.h"
#include "cobalt/cssom/css_rule_list.h"
#include "cobalt/cssom/css_style_rule.h"
#include "cobalt/cssom/css_style_sheet.h"
#include "cobalt/cssom/descendant_combinator.h"
#include "cobalt/cssom/empty_pseudo_class.h"
#include "cobalt/cssom/focus_pseudo_class.h"
#include "cobalt/cssom/following_sibling_combinator.h"
#include "cobalt/cssom/font_style_value.h"
#include "cobalt/cssom/font_weight_value.h"
#include "cobalt/cssom/hover_pseudo_class.h"
#include "cobalt/cssom/id_selector.h"
#include "cobalt/cssom/integer_value.h"
#include "cobalt/cssom/keyword_value.h"
#include "cobalt/cssom/length_value.h"
#include "cobalt/cssom/linear_gradient_value.h"
#include "cobalt/cssom/local_src_value.h"
#include "cobalt/cssom/matrix_function.h"
#include "cobalt/cssom/media_list.h"
#include "cobalt/cssom/media_query.h"
#include "cobalt/cssom/next_sibling_combinator.h"
#include "cobalt/cssom/not_pseudo_class.h"
#include "cobalt/cssom/number_value.h"
#include "cobalt/cssom/percentage_value.h"
#include "cobalt/cssom/property_definitions.h"
#include "cobalt/cssom/property_key_list_value.h"
#include "cobalt/cssom/property_list_value.h"
#include "cobalt/cssom/property_value_visitor.h"
#include "cobalt/cssom/radial_gradient_value.h"
#include "cobalt/cssom/rgba_color_value.h"
#include "cobalt/cssom/rotate_function.h"
#include "cobalt/cssom/scale_function.h"
#include "cobalt/cssom/shadow_value.h"
#include "cobalt/cssom/simple_selector.h"
#include "cobalt/cssom/string_value.h"
#include "cobalt/cssom/time_list_value.h"
#include "cobalt/cssom/timing_function.h"
#include "cobalt/cssom/timing_function_list_value.h"
#include "cobalt/cssom/transform_function_list_value.h"
#include "cobalt/cssom/translate_function.h"
#include "cobalt/cssom/type_selector.h"
#include "cobalt/cssom/unicode_range_value.h"
#include "cobalt/cssom/universal_selector.h"
#include "cobalt/cssom/url_src_value.h"
#include "cobalt/cssom/url_value.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace cobalt {
namespace css_parser {

using ::testing::_;
using ::testing::AtLeast;

class MockParserObserver {
 public:
  MOCK_METHOD1(OnWarning, void(const std::string& message));
  MOCK_METHOD1(OnError, void(const std::string& message));
};

class ParserTest : public ::testing::Test {
 public:
  ParserTest();
  ~ParserTest() OVERRIDE {}

 protected:
  ::testing::StrictMock<MockParserObserver> parser_observer_;
  Parser parser_;
  const base::SourceLocation source_location_;
};

ParserTest::ParserTest()
    : parser_(base::Bind(&MockParserObserver::OnWarning,
                         base::Unretained(&parser_observer_)),
              base::Bind(&MockParserObserver::OnError,
                         base::Unretained(&parser_observer_)),
              Parser::kShort),
      source_location_("[object ParserTest]", 1, 1) {}

// TODO: Test every reduction that has semantic action.

TEST_F(ParserTest, ParsesEmptyInput) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, HandlesInvalidAtRuleEndsWithSemicolons) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:1: warning: invalid rule @casino-royale"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("@casino-royale;", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, HandlesInvalidAtRuleWithoutSemicolonsAtTheEndOfFile) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:1: warning: invalid rule @casino-royale"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("@casino-royale", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, HandlesInvalidAtRuleWithNoMatchingEndBrace) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:1: warning: invalid rule @casino-royale"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("@casino-royale }", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, ComputesErrorLocationOnFirstLine) {
  EXPECT_CALL(
      parser_observer_,
      OnError("[object ParserTest]:10:18: error: unrecoverable syntax error"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "cucumber", base::SourceLocation("[object ParserTest]", 10, 10));
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, ComputesErrorLocationOnSecondLine) {
  EXPECT_CALL(
      parser_observer_,
      OnError("[object ParserTest]:11:9: error: unrecoverable syntax error"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "\n"
      "cucumber",
      base::SourceLocation("[object ParserTest]", 10, 10));
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, IgnoresSgmlCommentDelimiters) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("<!-- body {} -->", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(1, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, RecoversFromInvalidAtToken) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:9: warning: invalid rule @cobalt-magic"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "body {} @cobalt-magic; div {}", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(2, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, RecoversFromInvalidRuleWhichEndsWithSemicolon) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:9: warning: invalid rule @charset"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "body {} @charset 'utf-8'; div {}", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(2, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, RecoversFromInvalidRuleWhichEndsWithBlock) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:9: warning: invalid qualified rule"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("body {} !important {} div {}", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(2, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, SemicolonsDonotEndQualifiedRules) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:1: warning: invalid qualified rule"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("foo; bar {} div {}", source_location_);
  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(1, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, ParsesClassSelector) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(".my-class {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::ClassSelector* class_selector =
      dynamic_cast<cssom::ClassSelector*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(class_selector);
  EXPECT_EQ("my-class", class_selector->class_name());
}

TEST_F(ParserTest, ParsesAfterPseudoElementCSS2) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":after {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::AfterPseudoElement* after_pseudo_element =
      dynamic_cast<cssom::AfterPseudoElement*>(
          const_cast<cssom::SimpleSelector*>(
              compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(after_pseudo_element);
}

TEST_F(ParserTest, ParsesAfterPseudoElementCSS3) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("::after {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::AfterPseudoElement* after_pseudo_element =
      dynamic_cast<cssom::AfterPseudoElement*>(
          const_cast<cssom::SimpleSelector*>(
              compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(after_pseudo_element);
}

TEST_F(ParserTest, ParsesBeforePseudoElementCSS2) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":before {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::BeforePseudoElement* before_pseudo_element =
      dynamic_cast<cssom::BeforePseudoElement*>(
          const_cast<cssom::SimpleSelector*>(
              compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(before_pseudo_element);
}

TEST_F(ParserTest, ParsesBeforePseudoElementCSS3) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("::before {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::BeforePseudoElement* before_pseudo_element =
      dynamic_cast<cssom::BeforePseudoElement*>(
          const_cast<cssom::SimpleSelector*>(
              compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(before_pseudo_element);
}

TEST_F(ParserTest, ParsesActivePseudoClass) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":active {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::ActivePseudoClass* active_pseudo_class =
      dynamic_cast<cssom::ActivePseudoClass*>(
          const_cast<cssom::SimpleSelector*>(
              compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(active_pseudo_class);
}

TEST_F(ParserTest, ParsesEmptyPseudoClass) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":empty {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::EmptyPseudoClass* empty_pseudo_class =
      dynamic_cast<cssom::EmptyPseudoClass*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(empty_pseudo_class);
}

TEST_F(ParserTest, ParsesFocusPseudoClass) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":focus {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::FocusPseudoClass* focus_pseudo_class =
      dynamic_cast<cssom::FocusPseudoClass*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(focus_pseudo_class);
}

TEST_F(ParserTest, ParsesHoverPseudoClass) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":hover {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::HoverPseudoClass* hover_pseudo_class =
      dynamic_cast<cssom::HoverPseudoClass*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(hover_pseudo_class);
}

TEST_F(ParserTest, ParsesNotPseudoClass) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":not(div.my-class) {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::NotPseudoClass* not_pseudo_class =
      dynamic_cast<cssom::NotPseudoClass*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(not_pseudo_class);

  // Check the selector within :not pseudo class.
  cssom::CompoundSelector* not_compound_selector = not_pseudo_class->selector();
  ASSERT_TRUE(not_compound_selector);
  ASSERT_EQ(2, not_compound_selector->simple_selectors().size());
  cssom::TypeSelector* type_selector =
      dynamic_cast<cssom::TypeSelector*>(const_cast<cssom::SimpleSelector*>(
          not_compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(type_selector);
  EXPECT_EQ("div", type_selector->element_name());
  cssom::ClassSelector* class_selector =
      dynamic_cast<cssom::ClassSelector*>(const_cast<cssom::SimpleSelector*>(
          not_compound_selector->simple_selectors()[1]));
  ASSERT_TRUE(class_selector);
  EXPECT_EQ("my-class", class_selector->class_name());
}

TEST_F(ParserTest, ParsesNotPseudoClassShouldNotTakeEmptyParameter) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:1: warning: unsupported "
                        "selector within :not()"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":not() {}", source_location_);

  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, ParsesNotPseudoClassShouldNotTakeComplexSelector) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:1: warning: unsupported "
                        "selector within :not()"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet(":not(div span) {}", source_location_);

  EXPECT_EQ(0, style_sheet->css_rules()->length());
}

TEST_F(ParserTest, ParsesIdSelector) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("#my-id {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::IdSelector* id_selector =
      dynamic_cast<cssom::IdSelector*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(id_selector);
  EXPECT_EQ("my-id", id_selector->id());
}

TEST_F(ParserTest, ParsesTypeSelector) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("div {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::TypeSelector* type_selector =
      dynamic_cast<cssom::TypeSelector*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(type_selector);
  EXPECT_EQ("div", type_selector->element_name());
}

TEST_F(ParserTest, ParsesUniversalSelector) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("* {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(1, compound_selector->simple_selectors().size());
  cssom::UniversalSelector* universal_selector =
      dynamic_cast<cssom::UniversalSelector*>(
          const_cast<cssom::SimpleSelector*>(
              compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(universal_selector);
}

TEST_F(ParserTest, ParsesCompoundSelector) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("div.my-class {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  cssom::CompoundSelector* compound_selector =
      complex_selector->first_selector();
  ASSERT_TRUE(compound_selector);
  ASSERT_EQ(2, compound_selector->simple_selectors().size());
  cssom::TypeSelector* type_selector =
      dynamic_cast<cssom::TypeSelector*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[0]));
  ASSERT_TRUE(type_selector);
  EXPECT_EQ("div", type_selector->element_name());
  cssom::ClassSelector* class_selector =
      dynamic_cast<cssom::ClassSelector*>(const_cast<cssom::SimpleSelector*>(
          compound_selector->simple_selectors()[1]));
  ASSERT_TRUE(class_selector);
  EXPECT_EQ("my-class", class_selector->class_name());
}

TEST_F(ParserTest, ParsesComplexSelectorDescendantCombinator) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("div div {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  ASSERT_TRUE(complex_selector->first_selector());
  cssom::CompoundSelector* selector = complex_selector->first_selector();
  ASSERT_TRUE(selector->right_combinator());
  EXPECT_EQ(cssom::kDescendantCombinator,
            selector->right_combinator()->GetCombinatorType());
}

TEST_F(ParserTest, ParsesComplexSelectorFollowingSiblingCombinator) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("div ~ div {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  ASSERT_TRUE(complex_selector->first_selector());
  cssom::CompoundSelector* selector = complex_selector->first_selector();
  ASSERT_TRUE(selector->right_combinator());
  EXPECT_EQ(cssom::kFollowingSiblingCombinator,
            selector->right_combinator()->GetCombinatorType());
}

TEST_F(ParserTest, ParsesComplexSelectorChildCombinator) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("div > div {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  ASSERT_TRUE(complex_selector->first_selector());
  cssom::CompoundSelector* selector = complex_selector->first_selector();
  ASSERT_TRUE(selector->right_combinator());
  EXPECT_EQ(cssom::kChildCombinator,
            selector->right_combinator()->GetCombinatorType());
}

TEST_F(ParserTest, ParsesComplexSelectorNextSiblingCombinator) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("div + div {}", source_location_);

  ASSERT_EQ(1, style_sheet->css_rules()->length());
  ASSERT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
  cssom::CSSStyleRule* style_rule = static_cast<cssom::CSSStyleRule*>(
      style_sheet->css_rules()->Item(0).get());
  ASSERT_EQ(1, style_rule->selectors().size());
  cssom::ComplexSelector* complex_selector =
      dynamic_cast<cssom::ComplexSelector*>(
          const_cast<cssom::Selector*>(style_rule->selectors()[0]));
  ASSERT_TRUE(complex_selector);
  ASSERT_TRUE(complex_selector->first_selector());
  cssom::CompoundSelector* selector = complex_selector->first_selector();
  ASSERT_TRUE(selector->right_combinator());
  EXPECT_EQ(cssom::kNextSiblingCombinator,
            selector->right_combinator()->GetCombinatorType());
}

TEST_F(ParserTest, ParsesDeclarationListWithTrailingSemicolon) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "color: #0047ab;  /* Cobalt blue */\n"
          "font-size: 100px;\n",
          source_location_);

  EXPECT_TRUE(style->GetPropertyValue(cssom::kColorProperty));
  EXPECT_TRUE(style->GetPropertyValue(cssom::kFontSizeProperty));
}

TEST_F(ParserTest, ParsesDeclarationListWithoutTrailingSemicolon) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "color: #0047ab;\n"
          "font-size: 100px\n",
          source_location_);

  EXPECT_TRUE(style->GetPropertyValue(cssom::kColorProperty));
  EXPECT_TRUE(style->GetPropertyValue(cssom::kFontSizeProperty));
}

TEST_F(ParserTest, ParsesDeclarationListWithEmptyDeclaration) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "color: #0047ab;\n"
          ";\n"
          "font-size: 100px;\n",
          source_location_);

  EXPECT_TRUE(style->GetPropertyValue(cssom::kColorProperty));
  EXPECT_TRUE(style->GetPropertyValue(cssom::kFontSizeProperty));
}

TEST_F(ParserTest, RecoversFromInvalidPropertyDeclaration) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:2:1: warning: invalid declaration"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "color: #0047ab;\n"
          "1px;\n"
          "font-size: 100px;\n",
          source_location_);

  EXPECT_TRUE(style->GetPropertyValue(cssom::kColorProperty));
  EXPECT_TRUE(style->GetPropertyValue(cssom::kFontSizeProperty));
}

TEST_F(ParserTest, HandlesUnsupportedPropertyInStyleDeclarationList) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:1: warning: unsupported style property: src"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("src: initial;", source_location_);

  EXPECT_EQ(style->length(), 0);
}

TEST_F(ParserTest,
       HandlesUnsupportedPropertyInStyleDeclarationListWithSupportedProperty) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:1: warning: unsupported style "
                        "property: unicode-range"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("width: 100px; unicode-range: U+100;",
                                        source_location_);

  EXPECT_EQ(style->length(), 1);

  scoped_refptr<cssom::LengthValue> width = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kWidthProperty).get());
  ASSERT_TRUE(width);
  EXPECT_EQ(100, width->value());
  EXPECT_EQ(cssom::kPixelsUnit, width->unit());
}

TEST_F(ParserTest, SilentlyIgnoresNonWebKitProperties) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "-moz-transform: scale(2);\n"
          "-ms-transform: scale(2);\n"
          "-o-transform: scale(2);\n"
          "transform: scale(2);\n",
          source_location_);

  EXPECT_TRUE(style->GetPropertyValue(cssom::kTransformProperty));
}

TEST_F(ParserTest, WarnsAboutInvalidDeclaration) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:1: warning: unsupported property pony"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "pony: rainbowdash;\n"
          "color: #9edbf9;\n",
          source_location_);

  scoped_refptr<cssom::RGBAColorValue> color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kColorProperty).get());
  ASSERT_TRUE(color);
  EXPECT_EQ(0x9edbf9ff, color->value());
}

TEST_F(ParserTest, WarnsAboutInvalidDeclarationAtTheEndOfBlock) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:10: warning: "
                                          "unsupported property hallelujah"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      ":empty { hallelujah: rainbowdash }", source_location_);
}

TEST_F(ParserTest, WarnsAboutInvalidPropertyValues) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:19: warning: unsupported value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-color: morning haze over Paris;\n"
          "color: #fff;\n",
          source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBackgroundColorProperty));
  EXPECT_TRUE(style->GetPropertyValue(cssom::kColorProperty));
}

TEST_F(ParserTest, WarnsAboutInvalidAtRule) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:1: warning: invalid rule @wuli-style"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "@wuli-style winners-list {"
      "  from ["
      "    opacity: 0.6;"
      "  ]"
      "  to ["
      "    opacity: 0.8;"
      "  ]"
      "}\n"
      "#my-id {} \n",
      source_location_);

  EXPECT_EQ(1, style_sheet->css_rules()->length());
  EXPECT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
}

TEST_F(ParserTest, WarnsAboutInvalidAtRuleCurlyBraceInsideOfAnotherBlock) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:1: warning: invalid rule @foo-style"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "@foo-style winners-list {"
      "  from ["
      "    opacity: 0.6; }"
      "  ]"
      "  to ["
      "    opacity: 0.8;"
      "  ]"
      "}\n"
      "#my-id {} \n",
      source_location_);

  EXPECT_EQ(1, style_sheet->css_rules()->length());
  EXPECT_EQ(cssom::CSSRule::kStyleRule,
            style_sheet->css_rules()->Item(0)->type());
}

TEST_F(ParserTest, StyleSheetEndsWhileRuleIsStillOpen) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "@keyframes foo3 {"
      "  from {"
      "    opacity: 0.6;"
      "  }"
      "  to {"
      "    opacity: 0.8;",
      source_location_);

  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(1, style_sheet->css_rules()->length());

  cssom::CSSKeyframesRule* keyframes_rule =
      dynamic_cast<cssom::CSSKeyframesRule*>(
          style_sheet->css_rules()->Item(0).get());
  ASSERT_TRUE(keyframes_rule);
  EXPECT_EQ("foo3", keyframes_rule->name());

  ASSERT_EQ(2, keyframes_rule->css_rules()->length());
}

TEST_F(ParserTest, StyleSheetEndsWhileUnrecognizedAtRuleIsStillOpen) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:1: warning: invalid rule @user-defined"));

  scoped_refptr<cssom::CSSStyleSheet> style_sheet =
      parser_.ParseStyleSheet("@user-defined { abc[", source_location_);
}

TEST_F(ParserTest, StyleSheetEndsWhileDeclarationIsStillOpen) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: inherit",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kBackgroundColorProperty));
}

TEST_F(ParserTest, StyleSheetEndsWhileUrlIsStillOpen) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-image: url(foo.png",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());
}

TEST_F(ParserTest, StyleSheetEndsWhileFunctionIsStillOpen) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translateX(20%",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::TranslateFunction* translate_function =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function);

  ASSERT_EQ(cssom::TranslateFunction::kPercentage,
            translate_function->offset_type());
  scoped_refptr<cssom::PercentageValue> offset =
      translate_function->offset_as_percentage();
  EXPECT_FLOAT_EQ(0.2f, offset->value());
  EXPECT_EQ(cssom::TranslateFunction::kXAxis, translate_function->axis());
}

TEST_F(ParserTest, ParsesInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kBackgroundColorProperty));
}

TEST_F(ParserTest, ParsesInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kBackgroundColorProperty));
}

TEST_F(ParserTest, ParsesBackgroundWithOnlyColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background: rgba(0, 0, 0, .8);",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000000cc, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundWithOnlyRepeat) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background: no-repeat;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_repeat_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat_list);
  EXPECT_EQ(2, background_repeat_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[0]);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundWithColorAndURL) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: url(foo.png) rgba(0, 0, 0, .8);", source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000000cc, background_color->value());

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());
}

TEST_F(ParserTest, ParsesBackgroundWithColorAndURLInDifferentOrder) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: rgba(0, 0, 0, .8) url(foo.png);", source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000000cc, background_color->value());

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());
}

TEST_F(ParserTest, ParsesBackgroundWithColorAndPosition) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: rgba(0, 0, 0, .8) 70px 45%;", source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000000cc, background_color->value());

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);

  scoped_refptr<cssom::LengthValue> length_value_left =
      dynamic_cast<cssom::LengthValue*>(
          background_position_list->value()[0].get());
  EXPECT_FLOAT_EQ(70, length_value_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, length_value_left->unit());

  scoped_refptr<cssom::PercentageValue> percentage_value_right =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[1].get());
  EXPECT_FLOAT_EQ(0.45f, percentage_value_right->value());
}

TEST_F(ParserTest, ParsesBackgroundWithColorAndPositionInDifferentOrder) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: 70px 45% rgba(0, 0, 0, .8);", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);

  scoped_refptr<cssom::LengthValue> length_value_left =
      dynamic_cast<cssom::LengthValue*>(
          background_position_list->value()[0].get());
  EXPECT_FLOAT_EQ(70, length_value_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, length_value_left->unit());

  scoped_refptr<cssom::PercentageValue> percentage_value_right =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[1].get());
  EXPECT_FLOAT_EQ(0.45f, percentage_value_right->value());

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000000cc, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundWithURLPositionAndSize) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: url(foo.png) center / 50px 80px;", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);

  EXPECT_EQ(1, background_position_list->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[0]);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);

  scoped_refptr<cssom::LengthValue> size_value_left =
      dynamic_cast<cssom::LengthValue*>(background_size_list->value()[0].get());
  EXPECT_FLOAT_EQ(50, size_value_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, size_value_left->unit());

  scoped_refptr<cssom::LengthValue> size_value_right =
      dynamic_cast<cssom::LengthValue*>(background_size_list->value()[1].get());
  EXPECT_FLOAT_EQ(80, size_value_right->value());
  EXPECT_EQ(cssom::kPixelsUnit, size_value_right->unit());
}

TEST_F(ParserTest, ParsesBackgroundWithURLPositionAndSizeInDifferentOrder) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: center/50px 80px url(foo.png);", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);

  EXPECT_EQ(1, background_position_list->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[0]);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);

  scoped_refptr<cssom::LengthValue> size_value_left =
      dynamic_cast<cssom::LengthValue*>(background_size_list->value()[0].get());
  EXPECT_FLOAT_EQ(50, size_value_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, size_value_left->unit());

  scoped_refptr<cssom::LengthValue> size_value_right =
      dynamic_cast<cssom::LengthValue*>(background_size_list->value()[1].get());
  EXPECT_FLOAT_EQ(80, size_value_right->value());
  EXPECT_EQ(cssom::kPixelsUnit, size_value_right->unit());
}

TEST_F(ParserTest, ParsesBackgroundWithURLNoRepeat) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background: url(foo.png) no-repeat",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());

  scoped_refptr<cssom::PropertyListValue> background_repeat =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundWithNoRepeatAndColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: no-repeat rgba(0, 0, 0, .8);", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_repeat =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[1]);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000000cc, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundWithBackgroundRepeatProperty) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: url(foo.png); background-repeat: no-repeat;",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());

  scoped_refptr<cssom::PropertyListValue> background_repeat =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat);
}

TEST_F(ParserTest, ParsesBackgroundWithURLNoRepeatAndPosition) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: url(foo.png) center no-repeat", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);

  EXPECT_EQ(1, background_position_list->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[0]);

  scoped_refptr<cssom::PropertyListValue> background_repeat =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundWithNoRepeatAndCenter) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background: no-repeat center",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);

  EXPECT_EQ(1, background_position_list->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[0]);

  scoped_refptr<cssom::PropertyListValue> background_repeat =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(), background_repeat->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundWithNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background: none;", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetNone(), background_image_list->value()[0]);
}

TEST_F(ParserTest, ParsesBackgroundWithTransparent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background: transparent;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x00000000, background_color->value());
}

TEST_F(ParserTest, InvalidBackgroundWithTwoPositions) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:11: error: background-position or "
                      "background-repeat declared twice in background."));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: 0 0 rgba(255,255,255,.1) 100%", source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBackgroundColorProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBackgroundImageProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBackgroundPositionProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBackgroundRepeatProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBackgroundSizeProperty));
}

TEST_F(ParserTest, LinearGradientWithOneColorStopIsError) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:11: warning: unsupported value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: linear-gradient(to right, rgba(0,0,0,0.9));",
          source_location_);

  EXPECT_EQ(GetPropertyInitialValue(cssom::kBackgroundImageProperty),
            style->GetPropertyValue(cssom::kBackgroundImageProperty));
}

TEST_F(ParserTest, LinearGradientWithInvalidColorStopIsError) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:11: warning: unsupported value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: linear-gradient(#0123456789abcde 0%));",
          source_location_);

  EXPECT_EQ(GetPropertyInitialValue(cssom::kBackgroundImageProperty),
            style->GetPropertyValue(cssom::kBackgroundImageProperty));
}

TEST_F(ParserTest, RadialGradientWithOneColorStopIsError) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:11: warning: unsupported value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: radial-gradient(closest-corner, rgba(0,0,0,0.9));",
          source_location_);

  EXPECT_EQ(GetPropertyInitialValue(cssom::kBackgroundImageProperty),
            style->GetPropertyValue(cssom::kBackgroundImageProperty));
}

TEST_F(ParserTest, ParsesBackgroundWithLinearGradient) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: linear-gradient(rgba(0,0,0,0.56), rgba(0,0,0,0.9));",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::LinearGradientValue> linear_gradient_value =
      dynamic_cast<cssom::LinearGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_FALSE(linear_gradient_value->angle_in_radians());
  EXPECT_EQ(cssom::LinearGradientValue::kBottom,
            *linear_gradient_value->side_or_corner());

  const cssom::ColorStopList& color_stop_list_value =
      linear_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  float color_list[2] = {0x0000008E, 0x000000E5};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());
    EXPECT_FALSE(color_stop_value->position());
  }
}

TEST_F(ParserTest, ParsesBackgroundWithLinearGradientContainsTransparent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: linear-gradient(to bottom, rgba(0,0,0,0.56), "
          "rgba(0,0,0,0.9), transparent);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::LinearGradientValue> linear_gradient_value =
      dynamic_cast<cssom::LinearGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_FALSE(linear_gradient_value->angle_in_radians());
  EXPECT_EQ(cssom::LinearGradientValue::kBottom,
            *linear_gradient_value->side_or_corner());

  const cssom::ColorStopList& color_stop_list_value =
      linear_gradient_value->color_stop_list();
  EXPECT_EQ(3, color_stop_list_value.size());

  float color_list[3] = {0x0000008E, 0x000000E5, 0x00000000};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());
    EXPECT_FALSE(color_stop_value->position());
  }
}

TEST_F(ParserTest, ParsesBackgroundWithRadialGradient) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background: radial-gradient(closest-corner, "
          "rgba(0,0,0,0.56), rgba(0,0,0,0.9));",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::RadialGradientValue> radial_gradient_value =
      dynamic_cast<cssom::RadialGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_EQ(cssom::RadialGradientValue::kEllipse,
            radial_gradient_value->shape());
  EXPECT_EQ(cssom::RadialGradientValue::kClosestCorner,
            radial_gradient_value->size_keyword());
  EXPECT_FALSE(radial_gradient_value->size_value());

  scoped_refptr<cssom::PropertyListValue> position =
      radial_gradient_value->position();
  EXPECT_FALSE(position);

  const cssom::ColorStopList& color_stop_list_value =
      radial_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  float color_list[2] = {0x0000008E, 0x000000E5};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());
    EXPECT_FALSE(color_stop_value->position());
  }
}

TEST_F(ParserTest, ParsesBackgroundColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: #fff;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0xffffffff, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordAqua) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: aqua;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x00FFFFFF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordBlack) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: black;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000000FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordBlue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: blue;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x0000FFFF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordFuchsia) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: fuchsia;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0xFF00FFFF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordGray) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: gray;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x808080FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordGreen) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: green;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x008000FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordLime) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: lime;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x00FF00FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordMaroon) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: maroon;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x800000FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordNavy) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: navy;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x000080FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordOlive) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: olive;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x808000FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordPurple) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: purple;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x800080FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordRed) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: red;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0xFF0000FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordSilver) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: silver;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0xC0C0C0FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordTeal) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: teal;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x008080FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordTransparent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: transparent;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0x00000000, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordWhite) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: white;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0xFFFFFFFF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordYellow) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: yellow;",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> background_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBackgroundColorProperty).get());
  ASSERT_TRUE(background_color);
  EXPECT_EQ(0xFFFF00FF, background_color->value());
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kBackgroundColorProperty));
}

TEST_F(ParserTest, ParsesBackgroundColorWithKeywordInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-color: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kBackgroundColorProperty));
}

TEST_F(ParserTest, ParsesBackgroundImageNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-image: none;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetNone(), background_image_list->value()[0]);
}

TEST_F(ParserTest, ParsesBackgroundImageInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-image: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kBackgroundImageProperty));
}

TEST_F(ParserTest, ParsesBackgroundImageInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-image: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kBackgroundImageProperty));
}

TEST_F(ParserTest, ParsesSingleBackgroundImageURL) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-image: url(foo.png);",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value->value());
}

TEST_F(ParserTest, ParsesMultipleBackgroundImageURLs) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: url(foo.png), url(bar.jpg), url(baz.png);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(3, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value_1 =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value_1->value());

  scoped_refptr<cssom::URLValue> url_value_2 =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[1].get());
  EXPECT_EQ("bar.jpg", url_value_2->value());

  scoped_refptr<cssom::URLValue> url_value_3 =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[2].get());
  EXPECT_EQ("baz.png", url_value_3->value());
}

TEST_F(ParserTest, ParsesMultipleBackgroundImagesWithNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: url(foo.png), none, url(baz.png);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(3, background_image_list->value().size());

  scoped_refptr<cssom::URLValue> url_value_1 =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[0].get());
  EXPECT_EQ("foo.png", url_value_1->value());

  EXPECT_EQ(cssom::KeywordValue::GetNone(), background_image_list->value()[1]);

  scoped_refptr<cssom::URLValue> url_value_3 =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[2].get());
  EXPECT_EQ("baz.png", url_value_3->value());
}

TEST_F(ParserTest, ParsesBackgroundImageLinearGradientWithDirection) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: linear-gradient(180deg, rgba(34, 34, 34, 0) 50px,"
          "rgba(34, 34, 34, 0) 100px);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::LinearGradientValue> linear_gradient_value =
      dynamic_cast<cssom::LinearGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_FLOAT_EQ(static_cast<float>(M_PI),
                  *linear_gradient_value->angle_in_radians());
  EXPECT_FALSE(linear_gradient_value->side_or_corner());

  const cssom::ColorStopList& color_stop_list_value =
      linear_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  float percentage_list[2] = {50.0f, 100.0f};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(0x22222200, color->value());

    scoped_refptr<cssom::LengthValue> position =
        dynamic_cast<cssom::LengthValue*>(color_stop_value->position().get());
    EXPECT_FLOAT_EQ(percentage_list[i], position->value());
    EXPECT_EQ(cssom::kPixelsUnit, position->unit());
  }
}

TEST_F(ParserTest, ParsesBackgroundImageLinearGradientWithoutDirection) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: linear-gradient(rgba(34, 34, 34, 0),"
          "rgba(34, 34, 34, 0) 60%);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::LinearGradientValue> linear_gradient_value =
      dynamic_cast<cssom::LinearGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_FALSE(linear_gradient_value->angle_in_radians());
  EXPECT_EQ(cssom::LinearGradientValue::kBottom,
            *linear_gradient_value->side_or_corner());

  const cssom::ColorStopList& color_stop_list_value =
      linear_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(0x22222200, color->value());

    if (i == 0) {
      EXPECT_FALSE(color_stop_value->position());
    } else {
      scoped_refptr<cssom::PercentageValue> position =
          dynamic_cast<cssom::PercentageValue*>(
              color_stop_value->position().get());
      EXPECT_FLOAT_EQ(0.6f, position->value());
    }
  }
}

TEST_F(ParserTest, ParsesBackgroundImageLinearGradientAndURL) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: linear-gradient(to right top, "
          "rgba(34, 34, 34, 0) 0%, rgba(34, 34, 34, 0) 80px), url(foo.png), "
          "url(bar.jpg);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(3, background_image_list->value().size());

  scoped_refptr<cssom::LinearGradientValue> linear_gradient_value =
      dynamic_cast<cssom::LinearGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_FALSE(linear_gradient_value->angle_in_radians());
  EXPECT_EQ(cssom::LinearGradientValue::kTopRight,
            *linear_gradient_value->side_or_corner());

  const cssom::ColorStopList& color_stop_list_value =
      linear_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(0x22222200, color->value());

    if (i == 0) {
      scoped_refptr<cssom::PercentageValue> position =
          dynamic_cast<cssom::PercentageValue*>(
              color_stop_value->position().get());
      EXPECT_FLOAT_EQ(0.0f, position->value());
    } else {
      scoped_refptr<cssom::LengthValue> position =
          dynamic_cast<cssom::LengthValue*>(color_stop_value->position().get());
      EXPECT_FLOAT_EQ(80.0f, position->value());
      EXPECT_EQ(cssom::kPixelsUnit, position->unit());
    }
  }

  scoped_refptr<cssom::URLValue> background_image_1 =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[1].get());
  ASSERT_TRUE(background_image_1);
  EXPECT_EQ("foo.png", background_image_1->value());

  scoped_refptr<cssom::URLValue> background_image_2 =
      dynamic_cast<cssom::URLValue*>(background_image_list->value()[2].get());
  ASSERT_TRUE(background_image_2);
  EXPECT_EQ("bar.jpg", background_image_2->value());
}

TEST_F(ParserTest, ParsesBackgroundImageRadialGradientWithShapeAndSizeKeyword) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: radial-gradient(ellipse closest-side, "
          "rgba(0,0,0,0.2) 25%, rgba(0,0,0,0.1) 60%, rgba(0,0,0,0));",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::RadialGradientValue> radial_gradient_value =
      dynamic_cast<cssom::RadialGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_EQ(cssom::RadialGradientValue::kEllipse,
            radial_gradient_value->shape());
  EXPECT_EQ(cssom::RadialGradientValue::kClosestSide,
            radial_gradient_value->size_keyword());
  EXPECT_FALSE(radial_gradient_value->size_value());

  scoped_refptr<cssom::PropertyListValue> position =
      radial_gradient_value->position();
  EXPECT_FALSE(position);

  const cssom::ColorStopList& color_stop_list_value =
      radial_gradient_value->color_stop_list();
  EXPECT_EQ(3, color_stop_list_value.size());

  uint32 color_list[3] = {0x00000033, 0x00000019, 0x00000000};
  float color_stop_position_list[2] = {0.25f, 0.6f};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());

    if (i < 2) {
      scoped_refptr<cssom::PercentageValue> position_value =
          dynamic_cast<cssom::PercentageValue*>(
              color_stop_value->position().get());
      EXPECT_FLOAT_EQ(color_stop_position_list[i], position_value->value());
    } else {
      EXPECT_FALSE(color_stop_value->position());
    }
  }
}

TEST_F(ParserTest,
       ParsesBackgroundImageRadialGradientWithShapeSizeLengthAndPosition) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: radial-gradient(circle 20px at top center, "
          "rgba(0,0,0,0.2) 25%, rgba(0,0,0,0.1) 60%);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::RadialGradientValue> radial_gradient_value =
      dynamic_cast<cssom::RadialGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_EQ(cssom::RadialGradientValue::kCircle,
            radial_gradient_value->shape());
  EXPECT_FALSE(radial_gradient_value->size_keyword());

  scoped_refptr<cssom::PropertyListValue> size =
      radial_gradient_value->size_value();
  ASSERT_TRUE(size);
  EXPECT_EQ(1, size->value().size());

  scoped_refptr<cssom::LengthValue> size_value =
      dynamic_cast<cssom::LengthValue*>(size->value()[0].get());
  EXPECT_FLOAT_EQ(20.0f, size_value->value());
  EXPECT_EQ(cssom::kPixelsUnit, size_value->unit());

  scoped_refptr<cssom::PropertyListValue> position =
      radial_gradient_value->position();
  ASSERT_TRUE(position);
  EXPECT_EQ(2, position->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetTop(), position->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetCenter(), position->value()[1]);

  const cssom::ColorStopList& color_stop_list_value =
      radial_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  uint32 color_list[2] = {0x00000033, 0x00000019};
  float color_stop_position_list[2] = {0.25f, 0.6f};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());

    scoped_refptr<cssom::PercentageValue> color_stop_position_value =
        dynamic_cast<cssom::PercentageValue*>(
            color_stop_value->position().get());
    EXPECT_FLOAT_EQ(color_stop_position_list[i],
                    color_stop_position_value->value());
  }
}

TEST_F(ParserTest,
       ParsesBackgroundImageRadialGradientWithSizeShapeAndPosition) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: radial-gradient(2em circle at top center, "
          "rgba(0,0,0,0.2) 25%, rgba(0,0,0,0.1) 60%);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::RadialGradientValue> radial_gradient_value =
      dynamic_cast<cssom::RadialGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_EQ(cssom::RadialGradientValue::kCircle,
            radial_gradient_value->shape());
  EXPECT_FALSE(radial_gradient_value->size_keyword());

  scoped_refptr<cssom::PropertyListValue> size =
      radial_gradient_value->size_value();
  ASSERT_TRUE(size);
  EXPECT_EQ(1, size->value().size());

  scoped_refptr<cssom::LengthValue> size_value =
      dynamic_cast<cssom::LengthValue*>(size->value()[0].get());
  EXPECT_FLOAT_EQ(2.0f, size_value->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, size_value->unit());

  scoped_refptr<cssom::PropertyListValue> position =
      radial_gradient_value->position();
  ASSERT_TRUE(position);
  EXPECT_EQ(2, position->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetTop(), position->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetCenter(), position->value()[1]);

  const cssom::ColorStopList& color_stop_list_value =
      radial_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  uint32 color_list[2] = {0x00000033, 0x00000019};
  float color_stop_position_list[2] = {0.25f, 0.6f};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());

    scoped_refptr<cssom::PercentageValue> color_stop_position_value =
        dynamic_cast<cssom::PercentageValue*>(
            color_stop_value->position().get());
    EXPECT_FLOAT_EQ(color_stop_position_list[i],
                    color_stop_position_value->value());
  }
}

TEST_F(ParserTest, ParsesBackgroundImageRadialGradientWithSizeLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: radial-gradient(20px 60%, "
          "rgba(0,0,0,0.2) 25%, rgba(0,0,0,0.1) 60%);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::RadialGradientValue> radial_gradient_value =
      dynamic_cast<cssom::RadialGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_EQ(cssom::RadialGradientValue::kEllipse,
            radial_gradient_value->shape());
  EXPECT_FALSE(radial_gradient_value->size_keyword());

  scoped_refptr<cssom::PropertyListValue> size =
      radial_gradient_value->size_value();
  ASSERT_TRUE(size);
  EXPECT_EQ(2, size->value().size());

  scoped_refptr<cssom::LengthValue> side_value_horizontal =
      dynamic_cast<cssom::LengthValue*>(size->value()[0].get());
  EXPECT_FLOAT_EQ(20.0f, side_value_horizontal->value());
  EXPECT_EQ(cssom::kPixelsUnit, side_value_horizontal->unit());

  scoped_refptr<cssom::PercentageValue> side_value_vertical =
      dynamic_cast<cssom::PercentageValue*>(size->value()[1].get());
  EXPECT_FLOAT_EQ(0.6f, side_value_vertical->value());

  scoped_refptr<cssom::PropertyListValue> position =
      radial_gradient_value->position();
  EXPECT_FALSE(position);

  const cssom::ColorStopList& color_stop_list_value =
      radial_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  uint32 color_list[2] = {0x00000033, 0x00000019};
  float color_stop_position_list[2] = {0.25f, 0.6f};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());

    scoped_refptr<cssom::PercentageValue> color_stop_position_value =
        dynamic_cast<cssom::PercentageValue*>(
            color_stop_value->position().get());
    EXPECT_FLOAT_EQ(color_stop_position_list[i],
                    color_stop_position_value->value());
  }
}

TEST_F(ParserTest, ParsesBackgroundImageRadialGradientWithoutShapeAndSize) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: radial-gradient(at left, "
          "rgba(0,0,0,0.2) 25%, rgba(0,0,0,0.1) 60%);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::RadialGradientValue> radial_gradient_value =
      dynamic_cast<cssom::RadialGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_EQ(cssom::RadialGradientValue::kEllipse,
            radial_gradient_value->shape());
  EXPECT_EQ(cssom::RadialGradientValue::kFarthestCorner,
            radial_gradient_value->size_keyword());
  EXPECT_FALSE(radial_gradient_value->size_value());

  scoped_refptr<cssom::PropertyListValue> position =
      radial_gradient_value->position();
  ASSERT_TRUE(position);
  EXPECT_EQ(1, position->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetLeft(), position->value()[0]);

  const cssom::ColorStopList& color_stop_list_value =
      radial_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  uint32 color_list[2] = {0x00000033, 0x00000019};
  float color_stop_position_list[2] = {0.25f, 0.6f};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());

    scoped_refptr<cssom::PercentageValue> color_stop_position_value =
        dynamic_cast<cssom::PercentageValue*>(
            color_stop_value->position().get());
    EXPECT_FLOAT_EQ(color_stop_position_list[i],
                    color_stop_position_value->value());
  }
}

TEST_F(ParserTest, ParsesBackgroundImageRadialGradientOnlyHasColorStop) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-image: radial-gradient("
          "rgba(0,0,0,0.2) 25%, rgba(0,0,0,0.1) 60%);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> background_image_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundImageProperty).get());
  ASSERT_TRUE(background_image_list);
  EXPECT_EQ(1, background_image_list->value().size());

  scoped_refptr<cssom::RadialGradientValue> radial_gradient_value =
      dynamic_cast<cssom::RadialGradientValue*>(
          background_image_list->value()[0].get());
  EXPECT_EQ(cssom::RadialGradientValue::kEllipse,
            radial_gradient_value->shape());
  EXPECT_EQ(cssom::RadialGradientValue::kFarthestCorner,
            radial_gradient_value->size_keyword());
  EXPECT_FALSE(radial_gradient_value->size_value());

  scoped_refptr<cssom::PropertyListValue> position =
      radial_gradient_value->position();
  EXPECT_FALSE(position);

  const cssom::ColorStopList& color_stop_list_value =
      radial_gradient_value->color_stop_list();
  EXPECT_EQ(2, color_stop_list_value.size());

  uint32 color_list[2] = {0x00000033, 0x00000019};
  float color_stop_position_list[2] = {0.25f, 0.6f};

  for (size_t i = 0; i < color_stop_list_value.size(); ++i) {
    const cssom::ColorStop* color_stop_value = color_stop_list_value[i];
    scoped_refptr<cssom::RGBAColorValue> color = color_stop_value->rgba();
    ASSERT_TRUE(color);
    EXPECT_EQ(color_list[i], color->value());

    scoped_refptr<cssom::PercentageValue> color_stop_position_value =
        dynamic_cast<cssom::PercentageValue*>(
            color_stop_value->position().get());
    EXPECT_FLOAT_EQ(color_stop_position_list[i],
                    color_stop_position_value->value());
  }
}

TEST_F(ParserTest, ParsesBackgroundPositionCenter) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: center;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(1, background_position_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[0]);
}

TEST_F(ParserTest, ParsesBackgroundPositionOneValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: 20%;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(1, background_position_list->value().size());

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[0].get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(0.2f, percentage->value());
}

TEST_F(ParserTest, ParsesBackgroundPositionCenterLeft) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: center left;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetLeft(),
            background_position_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundPositionRightCenter) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: right center;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetRight(),
            background_position_list->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundPositionCenterCenter) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: center center;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundPositionValueCenter) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: 20px center;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  scoped_refptr<cssom::LengthValue> length = dynamic_cast<cssom::LengthValue*>(
      background_position_list->value()[0].get());
  ASSERT_TRUE(length);
  EXPECT_FLOAT_EQ(20, length->value());
  EXPECT_EQ(cssom::kPixelsUnit, length->unit());

  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            background_position_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundPositionBottomRight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: bottom right;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetBottom(),
            background_position_list->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetRight(),
            background_position_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundPositionWarnsAboutInvalidTwoValues_1) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:22: warning: "
                                          "invalid background position value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: top 20%;",
                                        source_location_);
}

TEST_F(ParserTest, ParsesBackgroundPositionWarnsAboutInvalidTwoValues_2) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:26: warning: "
                                          "invalid background position value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: 15% left;",
                                        source_location_);
}

TEST_F(ParserTest, ParsesBackgroundPositionWithThreeValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: left 10px top;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(3, background_position_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetLeft(),
            background_position_list->value()[0]);

  scoped_refptr<cssom::LengthValue> length = dynamic_cast<cssom::LengthValue*>(
      background_position_list->value()[1].get());
  ASSERT_TRUE(length);
  EXPECT_FLOAT_EQ(10, length->value());
  EXPECT_EQ(cssom::kPixelsUnit, length->unit());

  EXPECT_EQ(cssom::KeywordValue::GetTop(),
            background_position_list->value()[2]);
}

TEST_F(ParserTest, ParsesBackgroundPositionWarnsAboutInvalidThreeValues_1) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:22: warning: "
                                          "invalid background position value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: left 30px 15%;",
                                        source_location_);
}

TEST_F(ParserTest, ParsesBackgroundPositionWarnsAboutInvalidThreeValues_2) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:29: warning: "
                                          "invalid background position value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: bottom top 20%;",
                                        source_location_);
}

TEST_F(ParserTest, ParsesBackgroundPositionWarnsAboutInvalidThreeValues_3) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:33: warning: "
                                          "invalid background position value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-position: 20% bottom right;", source_location_);
}

TEST_F(ParserTest, ParsesBackgroundPositionWithFourValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-position: bottom 20% right 10%;", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(4, background_position_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetBottom(),
            background_position_list->value()[0]);

  scoped_refptr<cssom::PercentageValue> percentage_first =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[1].get());
  EXPECT_FLOAT_EQ(0.2f, percentage_first->value());

  EXPECT_EQ(cssom::KeywordValue::GetRight(),
            background_position_list->value()[2]);

  scoped_refptr<cssom::PercentageValue> percentage_second =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[3].get());
  EXPECT_FLOAT_EQ(0.1f, percentage_second->value());
}

TEST_F(ParserTest, ParsesBackgroundPositionWarnsAboutInvalidFourValues_1) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:32: warning: "
                                          "invalid background position value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-position: left 30px right 20%;", source_location_);
}

TEST_F(ParserTest, ParsesBackgroundPositionWarnsAboutInvalidFourValues_2) {
  EXPECT_CALL(parser_observer_, OnWarning("[object ParserTest]:1:32: warning: "
                                          "invalid background position value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-position: left 30px left 20%;", source_location_);
}

TEST_F(ParserTest, ParsesBackgroundPositionDoublePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: 60% 90%;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  scoped_refptr<cssom::PercentageValue> percentage_value_left =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[0].get());
  EXPECT_FLOAT_EQ(0.6f, percentage_value_left->value());

  scoped_refptr<cssom::PercentageValue> percentage_value_right =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[1].get());
  EXPECT_FLOAT_EQ(0.9f, percentage_value_right->value());
}

TEST_F(ParserTest, ParsesBackgroundPositionDoubleLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: 60px 90px;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  scoped_refptr<cssom::LengthValue> length_value_left =
      dynamic_cast<cssom::LengthValue*>(
          background_position_list->value()[0].get());
  EXPECT_FLOAT_EQ(60, length_value_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, length_value_left->unit());

  scoped_refptr<cssom::LengthValue> length_value_right =
      dynamic_cast<cssom::LengthValue*>(
          background_position_list->value()[1].get());
  EXPECT_FLOAT_EQ(90, length_value_right->value());
  EXPECT_EQ(cssom::kPixelsUnit, length_value_right->unit());
}

TEST_F(ParserTest, ParsesBackgroundPositionLengthAndPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: 60px 70%;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_position_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundPositionProperty).get());
  ASSERT_TRUE(background_position_list);
  EXPECT_EQ(2, background_position_list->value().size());

  scoped_refptr<cssom::LengthValue> length_value_left =
      dynamic_cast<cssom::LengthValue*>(
          background_position_list->value()[0].get());
  EXPECT_FLOAT_EQ(60, length_value_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, length_value_left->unit());

  scoped_refptr<cssom::PercentageValue> percentage_value_right =
      dynamic_cast<cssom::PercentageValue*>(
          background_position_list->value()[1].get());
  EXPECT_FLOAT_EQ(0.7f, percentage_value_right->value());
}

TEST_F(ParserTest, ParsesBackgroundPositionWithKeywordInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kBackgroundPositionProperty));
}

TEST_F(ParserTest, ParsesBackgroundPositionWithKeywordInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-position: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kBackgroundPositionProperty));
}

TEST_F(ParserTest, ParsesBackgroundRepeatNoRepeat) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-repeat: no-repeat;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_repeat_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat_list);
  EXPECT_EQ(2, background_repeat_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[0]);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundRepeatRepeat) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-repeat: repeat;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_repeat_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat_list);
  EXPECT_EQ(2, background_repeat_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetRepeat(),
            background_repeat_list->value()[0]);

  EXPECT_EQ(cssom::KeywordValue::GetRepeat(),
            background_repeat_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundRepeatNoRepeatSpecifiedTwice) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "background-repeat: no-repeat no-repeat;", source_location_);

  scoped_refptr<cssom::PropertyListValue> background_repeat_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat_list);
  EXPECT_EQ(2, background_repeat_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[0]);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundRepeatRepeatX) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-repeat: repeat-x;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_repeat_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat_list);
  EXPECT_EQ(2, background_repeat_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetRepeat(),
            background_repeat_list->value()[0]);

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundRepeatRepeatY) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-repeat: repeat-y;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_repeat_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundRepeatProperty).get());
  ASSERT_TRUE(background_repeat_list);
  EXPECT_EQ(2, background_repeat_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetNoRepeat(),
            background_repeat_list->value()[0]);

  EXPECT_EQ(cssom::KeywordValue::GetRepeat(),
            background_repeat_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundRepeatWithKeywordInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-repeat: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kBackgroundRepeatProperty));
}

TEST_F(ParserTest, ParsesBackgroundRepeatWithKeywordInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-repeat: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kBackgroundRepeatProperty));
}

TEST_F(ParserTest, ParsesBackgroundSizeContain) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: contain;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetContain(),
            style->GetPropertyValue(cssom::kBackgroundSizeProperty));
}

TEST_F(ParserTest, ParsesBackgroundSizeCover) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: cover;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetCover(),
            style->GetPropertyValue(cssom::kBackgroundSizeProperty));
}

TEST_F(ParserTest, ParsesBackgroundSizeSingleAuto) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: auto;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);
  EXPECT_EQ(2, background_size_list->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetAuto(), background_size_list->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetAuto(), background_size_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundSizeDoubleAuto) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: auto auto;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);
  EXPECT_EQ(2, background_size_list->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetAuto(), background_size_list->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetAuto(), background_size_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundSizeSinglePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: 20%;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);
  EXPECT_EQ(2, background_size_list->value().size());

  scoped_refptr<cssom::PercentageValue> percentage_value =
      dynamic_cast<cssom::PercentageValue*>(
          background_size_list->value()[0].get());
  EXPECT_FLOAT_EQ(0.2f, percentage_value->value());
  EXPECT_EQ(cssom::KeywordValue::GetAuto(), background_size_list->value()[1]);
}

TEST_F(ParserTest, ParsesBackgroundSizeDoublePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: 40% 60%;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);
  EXPECT_EQ(2, background_size_list->value().size());

  scoped_refptr<cssom::PercentageValue> percentage_value_left =
      dynamic_cast<cssom::PercentageValue*>(
          background_size_list->value()[0].get());
  scoped_refptr<cssom::PercentageValue> percentage_value_right =
      dynamic_cast<cssom::PercentageValue*>(
          background_size_list->value()[1].get());

  EXPECT_FLOAT_EQ(0.4f, percentage_value_left->value());
  EXPECT_FLOAT_EQ(0.6f, percentage_value_right->value());
}

TEST_F(ParserTest, ParsesBackgroundSizeOneAutoOnePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: auto 20%;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);
  EXPECT_EQ(2, background_size_list->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            background_size_list->value()[0].get());

  scoped_refptr<cssom::PercentageValue> percentage_value =
      dynamic_cast<cssom::PercentageValue*>(
          background_size_list->value()[1].get());
  EXPECT_FLOAT_EQ(0.2f, percentage_value->value());
}

TEST_F(ParserTest, ParsesBackgroundSizeOnePercentageOneAuto) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: 20% auto;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> background_size_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBackgroundSizeProperty).get());
  ASSERT_TRUE(background_size_list);
  EXPECT_EQ(2, background_size_list->value().size());

  scoped_refptr<cssom::PercentageValue> percentage_value =
      dynamic_cast<cssom::PercentageValue*>(
          background_size_list->value()[0].get());
  EXPECT_FLOAT_EQ(0.2f, percentage_value->value());

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            background_size_list->value()[1].get());
}

TEST_F(ParserTest, ParsesBackgroundSizeWithoutUnitIdentifier) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:16: error: non-zero length is "
                      "not allowed without unit identifier"));
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:16: warning: unsupported value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: 13px 12;",
                                        source_location_);
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBackgroundSizeProperty));
}

TEST_F(ParserTest, ParsesBackgroundSizeWithKeywordInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kBackgroundSizeProperty));
}

TEST_F(ParserTest, ParsesBackgroundSizeWithKeywordInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("background-size: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kBackgroundSizeProperty));
}

TEST_F(ParserTest, ParsesBorderWithWidthColorAndStyle) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border: .5em #fff solid;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(0.5f, border_left_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_left_width->unit());

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(0.5f, border_right_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_right_width->unit());

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(0.5f, border_top_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_top_width->unit());

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(0.5f, border_bottom_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_bottom_width->unit());

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0xffffffff, border_left_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0xffffffff, border_right_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0xffffffff, border_top_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0xffffffff, border_bottom_color->value());

  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderLeftStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderRightStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderTopStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderBottomStyleProperty));
}

TEST_F(ParserTest, ParsesBorderWithInvaildValue) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:9: warning: unsupported value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border: foo, bar;", source_location_);
}

TEST_F(ParserTest, ParsesBorderColorWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border: gray 20px;", source_location_);

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(20.0f, border_top_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_top_width->unit());

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(20.0f, border_right_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_right_width->unit());

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(20.0f, border_bottom_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_bottom_width->unit());

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(20.0f, border_left_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_left_width->unit());

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0x808080FF, border_top_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0x808080FF, border_right_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0x808080FF, border_bottom_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0x808080FF, border_left_color->value());
}

TEST_F(ParserTest, ParsesSingleBorderColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-color: rgba(0, 0, 0, .8);",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0x000000cc, border_left_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0x000000cc, border_right_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0x000000cc, border_top_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0x000000cc, border_bottom_color->value());
}

TEST_F(ParserTest, ParsesBorderColorWithTwoValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-color: #fff rgba(0, 0, 0, .8);",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0xFFFFFFFF, border_top_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0x000000cc, border_right_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0xFFFFFFFF, border_bottom_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0x000000cc, border_left_color->value());
}

TEST_F(ParserTest, ParsesBorderColorWithThreeValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-color: #fff rgba(0, 0, 0, .8) rgba(0,0,0,0.9);",
          source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0xFFFFFFFF, border_top_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0x000000cc, border_right_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0x000000E5, border_bottom_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0x000000cc, border_left_color->value());
}

TEST_F(ParserTest, ParsesBorderColorWithFourValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-color: #fff rgba(0, 0, 0, .8) rgba(0,0,0,0.9) "
          "rgba(0,0,0,0.56);",
          source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0xFFFFFFFF, border_top_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0x000000CC, border_right_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0x000000E5, border_bottom_color->value());

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0x0000008E, border_left_color->value());
}

TEST_F(ParserTest, ParsesBorderTopColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-top-color: rgba(0, 0, 0, .8);",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0x000000cc, border_top_color->value());
}

TEST_F(ParserTest, ParsesBorderRightColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-right-color: rgba(0, 0, 0, .8);", source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0x000000cc, border_right_color->value());
}

TEST_F(ParserTest, ParsesBorderBottomColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-bottom-color: rgba(0, 0, 0, .8);", source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0x000000cc, border_bottom_color->value());
}

TEST_F(ParserTest, ParsesBorderLeftColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-left-color: rgba(0, 0, 0, .8);",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0x000000cc, border_left_color->value());
}

TEST_F(ParserTest, ParsesSingleBorderWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-width: .8em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(0.8f, border_top_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_top_width->unit());

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(0.8f, border_right_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_right_width->unit());

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(0.8f, border_bottom_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_bottom_width->unit());

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(0.8f, border_left_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_left_width->unit());
}

TEST_F(ParserTest, ParsesBorderWidthWithTwoValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-width: .8em 20px;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(0.8f, border_top_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_top_width->unit());

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(20.0f, border_right_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_right_width->unit());

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(0.8f, border_bottom_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_bottom_width->unit());

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(20.0f, border_left_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_left_width->unit());
}

TEST_F(ParserTest, ParsesBorderWidthWithThreeValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-width: .8em 20px 30px;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(0.8f, border_top_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_top_width->unit());

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(20.0f, border_right_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_right_width->unit());

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(30.0f, border_bottom_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_bottom_width->unit());

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(20.0f, border_left_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_left_width->unit());
}

TEST_F(ParserTest, ParsesBorderWidthWithFourValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-width: .8em 20px 30px .5em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(0.8f, border_top_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_top_width->unit());

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(20.0f, border_right_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_right_width->unit());

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(30.0f, border_bottom_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_bottom_width->unit());

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(0.5f, border_left_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_left_width->unit());
}

TEST_F(ParserTest, ParsesBorderTopWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-top-width: .8em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(0.8f, border_top_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_top_width->unit());
}

TEST_F(ParserTest, ParsesBorderBottomWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-bottom-width: 35px;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(35.0f, border_bottom_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_bottom_width->unit());
}

TEST_F(ParserTest, ParsesBorderLeftWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-left-width: 20px;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(20.0f, border_left_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_left_width->unit());
}

TEST_F(ParserTest, ParsesBorderRightWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-right-width: .4em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(0.4f, border_right_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_right_width->unit());
}

TEST_F(ParserTest, ParsesSingleBorderStyleSolid) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-style: solid;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderLeftStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderRightStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderTopStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderBottomStyleProperty));
}

TEST_F(ParserTest, ParsesSingleBorderStyleHidden) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-style: hidden;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetHidden(),
            style->GetPropertyValue(cssom::kBorderLeftStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetHidden(),
            style->GetPropertyValue(cssom::kBorderRightStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetHidden(),
            style->GetPropertyValue(cssom::kBorderTopStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetHidden(),
            style->GetPropertyValue(cssom::kBorderBottomStyleProperty));
}

TEST_F(ParserTest, ParsesBorderTop) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-top: 1px solid #777;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_top_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderTopWidthProperty).get());
  ASSERT_TRUE(border_top_width);
  EXPECT_FLOAT_EQ(1.0f, border_top_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, border_top_width->unit());

  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderTopStyleProperty));

  scoped_refptr<cssom::RGBAColorValue> border_top_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderTopColorProperty).get());
  ASSERT_TRUE(border_top_color);
  EXPECT_EQ(0x777777FF, border_top_color->value());
}

TEST_F(ParserTest, ParsesBorderBottom) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-bottom: 1em solid "
          "rgba(255, 255, 255, .2);",
          source_location_);

  scoped_refptr<cssom::LengthValue> border_bottom_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderBottomWidthProperty).get());
  ASSERT_TRUE(border_bottom_width);
  EXPECT_FLOAT_EQ(1.0f, border_bottom_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_bottom_width->unit());

  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderBottomStyleProperty));

  scoped_refptr<cssom::RGBAColorValue> border_bottom_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderBottomColorProperty).get());
  ASSERT_TRUE(border_bottom_color);
  EXPECT_EQ(0xFFFFFF33, border_bottom_color->value());
}

TEST_F(ParserTest, ParsesBorderLeft) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-left: .7em solid transparent;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_left_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderLeftWidthProperty).get());
  ASSERT_TRUE(border_left_width);
  EXPECT_FLOAT_EQ(0.7f, border_left_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_left_width->unit());

  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderLeftStyleProperty));

  scoped_refptr<cssom::RGBAColorValue> border_left_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderLeftColorProperty).get());
  ASSERT_TRUE(border_left_color);
  EXPECT_EQ(0x00000000, border_left_color->value());
}

TEST_F(ParserTest, ParsesBorderRight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-right: .1em solid "
          "rgba(255, 255, 255, .2);",
          source_location_);

  scoped_refptr<cssom::LengthValue> border_right_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRightWidthProperty).get());
  ASSERT_TRUE(border_right_width);
  EXPECT_FLOAT_EQ(0.1f, border_right_width->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_right_width->unit());

  EXPECT_EQ(cssom::KeywordValue::GetSolid(),
            style->GetPropertyValue(cssom::kBorderRightStyleProperty));

  scoped_refptr<cssom::RGBAColorValue> border_right_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kBorderRightColorProperty).get());
  ASSERT_TRUE(border_right_color);
  EXPECT_EQ(0xFFFFFF33, border_right_color->value());
}

TEST_F(ParserTest, ParsesBorderColorWithInvalidNumberOfValues) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:13: warning: invalid number of "
                        "border color values"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-color: maroon green transparent #CdC transparent;",
          source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderTopColorProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderRightColorProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderBottomColorProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderLeftColorProperty));
}

TEST_F(ParserTest, ParsesBorderColorWithZeroValue) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:13: warning: invalid number of "
                        "border color values"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-color: ;", source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderTopColorProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderRightColorProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderBottomColorProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderLeftColorProperty));
}

TEST_F(ParserTest, ParsesBorderStyleWithInvalidNumberOfValues) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:13: warning: invalid number of "
                        "border style values"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-style: solid hidden none solid hidden;", source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderTopStyleProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderRightStyleProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderBottomStyleProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderLeftStyleProperty));
}

TEST_F(ParserTest, ParsesBorderStyleWithZeroValue) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:13: warning: invalid number of "
                        "border style values"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-style: ;", source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderTopStyleProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderRightStyleProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderBottomStyleProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderLeftStyleProperty));
}

TEST_F(ParserTest, ParsesBorderWidthWithInvalidNumberOfValues) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:13: warning: invalid number of "
                        "border width values"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "border-width: 0.2em 12px 0.8em 10px 0.2em 5px;", source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderTopWidthProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderRightWidthProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderBottomWidthProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderLeftWidthProperty));
}

TEST_F(ParserTest, ParsesBorderWidthWithZeroValue) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:13: warning: invalid number of "
                        "border width values"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-width: ;", source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderTopWidthProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderRightWidthProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderBottomWidthProperty));
  EXPECT_FALSE(style->GetPropertyValue(cssom::kBorderLeftWidthProperty));
}

TEST_F(ParserTest, ParsesBorderRadiusLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-radius: 0.2em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> border_radius =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kBorderRadiusProperty).get());
  ASSERT_TRUE(border_radius);
  EXPECT_FLOAT_EQ(0.2f, border_radius->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, border_radius->unit());
}

TEST_F(ParserTest, ParsesBorderRadiusPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("border-radius: 50%;",
                                        source_location_);

  scoped_refptr<cssom::PercentageValue> border_radius =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kBorderRadiusProperty).get());
  ASSERT_TRUE(border_radius);
  EXPECT_FLOAT_EQ(0.5f, border_radius->value());
}

TEST_F(ParserTest, ParsesBoxShadowWithNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("box-shadow: none;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kBoxShadowProperty));
}

TEST_F(ParserTest, ParsesBoxShadowWith2Lengths) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("box-shadow: .2em 20px;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> box_shadow_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBoxShadowProperty).get());

  EXPECT_EQ(1, box_shadow_list->value().size());
  scoped_refptr<cssom::ShadowValue> box_shadow =
      dynamic_cast<cssom::ShadowValue*>(box_shadow_list->value()[0].get());
  ASSERT_TRUE(box_shadow);
  EXPECT_TRUE(box_shadow->offset_x());
  EXPECT_TRUE(box_shadow->offset_y());
  EXPECT_FALSE(box_shadow->blur_radius());
  EXPECT_FALSE(box_shadow->spread_radius());

  EXPECT_FLOAT_EQ(.2f, box_shadow->offset_x()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, box_shadow->offset_x()->unit());

  EXPECT_FLOAT_EQ(20, box_shadow->offset_y()->value());
  EXPECT_EQ(cssom::kPixelsUnit, box_shadow->offset_y()->unit());

  EXPECT_FALSE(box_shadow->color());
  EXPECT_FALSE(box_shadow->has_inset());
}

TEST_F(ParserTest, ParsesBoxShadowWith3LengthsAndColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("box-shadow: gray .2em 20px .3em;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> box_shadow_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBoxShadowProperty).get());

  EXPECT_EQ(1, box_shadow_list->value().size());
  scoped_refptr<cssom::ShadowValue> box_shadow =
      dynamic_cast<cssom::ShadowValue*>(box_shadow_list->value()[0].get());
  ASSERT_TRUE(box_shadow);
  EXPECT_TRUE(box_shadow->offset_x());
  EXPECT_TRUE(box_shadow->offset_y());
  EXPECT_TRUE(box_shadow->blur_radius());
  EXPECT_FALSE(box_shadow->spread_radius());

  EXPECT_FLOAT_EQ(.2f, box_shadow->offset_x()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, box_shadow->offset_x()->unit());

  EXPECT_FLOAT_EQ(20, box_shadow->offset_y()->value());
  EXPECT_EQ(cssom::kPixelsUnit, box_shadow->offset_y()->unit());

  EXPECT_FLOAT_EQ(.3f, box_shadow->blur_radius()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, box_shadow->blur_radius()->unit());

  EXPECT_EQ(0x808080FF, box_shadow->color()->value());

  EXPECT_FALSE(box_shadow->has_inset());
}

TEST_F(ParserTest, ParsesBoxShadowWith4LengthsInsetAndColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "box-shadow: .2em 20px .3em 0 "
          "inset rgba(0, 0, 0, .8);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> box_shadow_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBoxShadowProperty).get());

  EXPECT_EQ(1, box_shadow_list->value().size());
  scoped_refptr<cssom::ShadowValue> box_shadow =
      dynamic_cast<cssom::ShadowValue*>(box_shadow_list->value()[0].get());
  ASSERT_TRUE(box_shadow);
  EXPECT_TRUE(box_shadow->offset_x());
  EXPECT_TRUE(box_shadow->offset_y());
  EXPECT_TRUE(box_shadow->blur_radius());
  EXPECT_TRUE(box_shadow->spread_radius());

  EXPECT_FLOAT_EQ(.2f, box_shadow->offset_x()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, box_shadow->offset_x()->unit());

  EXPECT_FLOAT_EQ(20, box_shadow->offset_y()->value());
  EXPECT_EQ(cssom::kPixelsUnit, box_shadow->offset_y()->unit());

  EXPECT_FLOAT_EQ(.3f, box_shadow->blur_radius()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, box_shadow->blur_radius()->unit());

  EXPECT_FLOAT_EQ(0, box_shadow->spread_radius()->value());
  EXPECT_EQ(cssom::kPixelsUnit, box_shadow->spread_radius()->unit());

  EXPECT_EQ(0x000000cc, box_shadow->color()->value());

  EXPECT_TRUE(box_shadow->has_inset());
}

TEST_F(ParserTest, ParsesBoxShadowWithCommaSeparatedList) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "box-shadow: .2em 20px .3em 0 rgba(0, 0, 0, 0.4), "
          "12px 20px .5em 8px inset rgba(0, 0, 0, .8);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> box_shadow_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kBoxShadowProperty).get());

  EXPECT_EQ(2, box_shadow_list->value().size());

  float expected_length_value[2][4] = {{0.2f, 20.0f, 0.3f, 0.0f},
                                       {12.0f, 20.0f, 0.5f, 8.0f}};
  cssom::LengthUnit expected_length_unit[2][4] = {
      {cssom::kFontSizesAkaEmUnit, cssom::kPixelsUnit,
       cssom::kFontSizesAkaEmUnit, cssom::kPixelsUnit},
      {cssom::kPixelsUnit, cssom::kPixelsUnit, cssom::kFontSizesAkaEmUnit,
       cssom::kPixelsUnit}};

  float expected_color[2] = {0x00000066, 0x000000cc};
  bool expected_has_inset[2] = {false, true};

  for (size_t i = 0; i < box_shadow_list->value().size(); ++i) {
    scoped_refptr<cssom::ShadowValue> box_shadow =
        dynamic_cast<cssom::ShadowValue*>(box_shadow_list->value()[i].get());
    ASSERT_TRUE(box_shadow);

    for (int j = 0; j < cssom::ShadowValue::kMaxLengths; ++j) {
      scoped_refptr<cssom::LengthValue> length_value = box_shadow->lengths()[j];
      EXPECT_FLOAT_EQ(expected_length_value[i][j], length_value->value());
      EXPECT_EQ(expected_length_unit[i][j], length_value->unit());
    }

    EXPECT_EQ(expected_color[i], box_shadow->color()->value());

    EXPECT_EQ(expected_has_inset[i], box_shadow->has_inset());
  }
}

TEST_F(ParserTest, ParsesBoxShadowWithWrongFormat) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:11: warning: invalid box shadow property."));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("box-shadow: 0.04em #123 inset;",
                                        source_location_);
}

TEST_F(ParserTest, Parses3DigitColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("color: #123;", source_location_);

  scoped_refptr<cssom::RGBAColorValue> color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kColorProperty).get());
  ASSERT_TRUE(color);
  EXPECT_EQ(0x112233ff, color->value());
}

TEST_F(ParserTest, Parses6DigitColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("color: #0047ab;  /* Cobalt blue */\n",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kColorProperty).get());
  ASSERT_TRUE(color);
  EXPECT_EQ(0x0047abff, color->value());
}

TEST_F(ParserTest, ParsesNoneContent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("content: none;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kContentProperty));
}

TEST_F(ParserTest, ParsesNormalContent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("content: normal;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNormal(),
            style->GetPropertyValue(cssom::kContentProperty));
}

TEST_F(ParserTest, ParsesURLContent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("content: url(foo.png);",
                                        source_location_);

  scoped_refptr<cssom::URLValue> content_image = dynamic_cast<cssom::URLValue*>(
      style->GetPropertyValue(cssom::kContentProperty).get());
  ASSERT_TRUE(content_image);
  EXPECT_EQ("foo.png", content_image->value());
}

TEST_F(ParserTest, ParsesStringContent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("content: \"cobalt FTW!\";",
                                        source_location_);

  scoped_refptr<cssom::StringValue> content = dynamic_cast<cssom::StringValue*>(
      style->GetPropertyValue(cssom::kContentProperty).get());
  ASSERT_TRUE(content);
  EXPECT_EQ("cobalt FTW!", content->value());
}

TEST_F(ParserTest, ParsesRGBColorWithOutOfRangeIntegers) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("color: rgb(300, 0, -300);",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kColorProperty).get());
  ASSERT_TRUE(color);
  EXPECT_EQ(0xff0000ff, color->value());
}

TEST_F(ParserTest, ParsesRGBAColorWithIntegers) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("color: rgba(255, 128, 1, 0.5);",
                                        source_location_);

  scoped_refptr<cssom::RGBAColorValue> color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kColorProperty).get());
  ASSERT_TRUE(color);
  EXPECT_EQ(0xff80017f, color->value());
}

TEST_F(ParserTest, ParsesBlockDisplay) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("display: block;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetBlock(),
            style->GetPropertyValue(cssom::kDisplayProperty));
}

TEST_F(ParserTest, ParsesInlineDisplay) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("display: inline;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInline(),
            style->GetPropertyValue(cssom::kDisplayProperty));
}

TEST_F(ParserTest, ParsesInlineBlockDisplay) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("display: inline-block;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInlineBlock(),
            style->GetPropertyValue(cssom::kDisplayProperty));
}

TEST_F(ParserTest, ParsesNoneDisplay) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("display: none;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kDisplayProperty));
}

TEST_F(ParserTest, ParsesFontShorthandInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: inherit;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kFontSizeProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kFontFamilyProperty));
}

TEST_F(ParserTest, ParsesFontShorthandInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: initial;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontSizeProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontFamilyProperty));
}

TEST_F(ParserTest, ParsesFontShorthandSizeFamily) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "font: 50px 'Roboto', Noto, sans-serif;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontWeightProperty));

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(50, font_size->value());
  EXPECT_EQ(cssom::kPixelsUnit, font_size->unit());

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 3);

  scoped_refptr<cssom::StringValue> font_family_name_1 =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_name_1);
  EXPECT_EQ("Roboto", font_family_name_1->value());

  scoped_refptr<cssom::StringValue> font_family_name_2 =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(1).get());
  ASSERT_TRUE(font_family_name_2);
  EXPECT_EQ("Noto", font_family_name_2->value());

  EXPECT_EQ(cssom::KeywordValue::GetSansSerif(),
            font_family_list->get_item_modulo_size(2));
}

TEST_F(ParserTest, ParsesFontShorthandStyleSizeFamily) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: italic 50em Noto;",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetItalic(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontWeightProperty));

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(50, font_size->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, font_size->unit());

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_name =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_name);
  EXPECT_EQ("Noto", font_family_name->value());
}

TEST_F(ParserTest, ParsesFontShorthandWeightSizeFamily) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: bold 10em sans-serif;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::FontWeightValue::GetBoldAka700(),
            style->GetPropertyValue(cssom::kFontWeightProperty));

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(10, font_size->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, font_size->unit());

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  EXPECT_EQ(cssom::KeywordValue::GetSansSerif(),
            font_family_list->get_item_modulo_size(0));
}

TEST_F(ParserTest, ParsesFontShorthandStyleWeightSizeFamily) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: italic 300 50px 'Roboto';",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetItalic(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::FontWeightValue::GetLightAka300(),
            style->GetPropertyValue(cssom::kFontWeightProperty));

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(50, font_size->value());
  EXPECT_EQ(cssom::kPixelsUnit, font_size->unit());

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_name =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_name);
  EXPECT_EQ("Roboto", font_family_name->value());
}

TEST_F(ParserTest, ParsesFontShorthandStyleNormal) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: normal 600 50px Roboto;",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetNormal(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::FontWeightValue::GetSemiBoldAka600(),
            style->GetPropertyValue(cssom::kFontWeightProperty));

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(50, font_size->value());
  EXPECT_EQ(cssom::kPixelsUnit, font_size->unit());

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_name =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_name);
  EXPECT_EQ("Roboto", font_family_name->value());
}

TEST_F(ParserTest, ParsesFontShorthandWeightNormal) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: italic normal 50px Roboto;",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetItalic(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::FontWeightValue::GetNormalAka400(),
            style->GetPropertyValue(cssom::kFontWeightProperty));

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(50, font_size->value());
  EXPECT_EQ(cssom::kPixelsUnit, font_size->unit());

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_name =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_name);
  EXPECT_EQ("Roboto", font_family_name->value());
}

TEST_F(ParserTest, ParsesFontShorthandStyleWeightNormal) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font: normal normal 50px Roboto;",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetNormal(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
  EXPECT_EQ(cssom::FontWeightValue::GetNormalAka400(),
            style->GetPropertyValue(cssom::kFontWeightProperty));

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(50, font_size->value());
  EXPECT_EQ(cssom::kPixelsUnit, font_size->unit());

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_name =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_name);
  EXPECT_EQ("Roboto", font_family_name->value());
}

TEST_F(ParserTest, ParsesFontFamilyInherit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kFontFamilyProperty));
}

TEST_F(ParserTest, ParsesFontFamilyInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontFamilyProperty));
}

TEST_F(ParserTest, ParsesFontFamilyGenericName) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: serif;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  EXPECT_EQ(cssom::KeywordValue::GetSerif(),
            font_family_list->get_item_modulo_size(0));
}

TEST_F(ParserTest, ParsesFontFamilySingleIdentifierName) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: Noto;", source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_string =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_string);
  EXPECT_EQ("Noto", font_family_string->value());
}

TEST_F(ParserTest, ParsesFontFamilySingleIdentifierPropertyName) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: content;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_string =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_string);
  EXPECT_EQ("content", font_family_string->value());
}

TEST_F(ParserTest, ParsesFontFamilyMultipleIdentifierName) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: Roboto;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_string =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_string);
  EXPECT_EQ("Roboto", font_family_string->value());
}

TEST_F(ParserTest, ParsesFontFamilyIdentifierNameContainingInheritKeyword) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: Droid inherit droid;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_string =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_string);
  EXPECT_EQ("Droid inherit droid", font_family_string->value());
}

TEST_F(ParserTest, ParsesFontFamilyIdentifierNameContainingGenericFont) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: Droid serif droid;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_string =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_string);
  EXPECT_EQ("Droid serif droid", font_family_string->value());
}

TEST_F(ParserTest, ParsesFontFamilyStringName) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-family: \"Roboto\";",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_string =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_string);
  EXPECT_EQ("Roboto", font_family_string->value());
}

TEST_F(ParserTest, ParsesFontFamilyList) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "font-family: 'Roboto', Noto, sans-serif;", source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kFontFamilyProperty).get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 3);

  scoped_refptr<cssom::StringValue> font_family_name_1 =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_name_1);
  EXPECT_EQ("Roboto", font_family_name_1->value());

  scoped_refptr<cssom::StringValue> font_family_name_2 =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(1).get());
  ASSERT_TRUE(font_family_name_2);
  EXPECT_EQ("Noto", font_family_name_2->value());

  EXPECT_EQ(cssom::KeywordValue::GetSansSerif(),
            font_family_list->get_item_modulo_size(2));
}

// TODO: Test negative length value.

TEST_F(ParserTest, ParsesLengthPxUnit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-size: 100px;", source_location_);

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(100, font_size->value());
  EXPECT_EQ(cssom::kPixelsUnit, font_size->unit());
}

TEST_F(ParserTest, ParsesLengthEmUnit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-size: 10em;", source_location_);

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(10, font_size->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, font_size->unit());
}

TEST_F(ParserTest, ParsesLengthRemUnit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-size: 10rem;", source_location_);

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(10, font_size->value());
  EXPECT_EQ(cssom::kRootElementFontSizesAkaRemUnit, font_size->unit());
}

TEST_F(ParserTest, ParsesLengthVwUnit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-size: 10vw;", source_location_);

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(10, font_size->value());
  EXPECT_EQ(cssom::kViewportWidthPercentsAkaVwUnit, font_size->unit());
}

TEST_F(ParserTest, ParsesLengthVhUnit) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-size: 10vh;", source_location_);

  scoped_refptr<cssom::LengthValue> font_size =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kFontSizeProperty).get());
  ASSERT_TRUE(font_size);
  EXPECT_FLOAT_EQ(10, font_size->value());
  EXPECT_EQ(cssom::kViewportHeightPercentsAkaVhUnit, font_size->unit());
}

TEST_F(ParserTest, ParsesNormalFontStyle) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-style: normal;",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetNormal(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
}

TEST_F(ParserTest, ParsesItalicFontStyle) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-style: italic;",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetItalic(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
}

TEST_F(ParserTest, ParsesObliqueFontStyle) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-style: oblique;",
                                        source_location_);

  EXPECT_EQ(cssom::FontStyleValue::GetOblique(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
}

TEST_F(ParserTest, ParsesInheritFontStyle) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-style: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
}

TEST_F(ParserTest, ParsesInitialFontStyle) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-style: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kFontStyleProperty));
}

TEST_F(ParserTest, ParsesNormalFontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: normal;",
                                        source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetNormalAka400(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, ParsesBoldFontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: bold;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetBoldAka700(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses100FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 100;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetThinAka100(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses200FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 200;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetExtraLightAka200(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses300FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 300;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetLightAka300(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses400FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 400;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetNormalAka400(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses500FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 500;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetMediumAka500(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses600FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 600;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetSemiBoldAka600(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses700FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 700;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetBoldAka700(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses800FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 800;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetExtraBoldAka800(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, Parses900FontWeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("font-weight: 900;", source_location_);

  EXPECT_EQ(cssom::FontWeightValue::GetBlackAka900(),
            style->GetPropertyValue(cssom::kFontWeightProperty));
}

TEST_F(ParserTest, ParsesHeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("height: 100px;", source_location_);

  scoped_refptr<cssom::LengthValue> height = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kHeightProperty).get());
  ASSERT_TRUE(height);
  EXPECT_FLOAT_EQ(100, height->value());
  EXPECT_EQ(cssom::kPixelsUnit, height->unit());
}

TEST_F(ParserTest, ParsesNormalLineHeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("line-height: normal;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNormal(),
            style->GetPropertyValue(cssom::kLineHeightProperty));
}

TEST_F(ParserTest, ParsesLineHeightInEm) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("line-height: 1.2em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> line_height =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kLineHeightProperty).get());
  ASSERT_TRUE(line_height);
  EXPECT_FLOAT_EQ(1.2f, line_height->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, line_height->unit());
}

TEST_F(ParserTest, ParsesLineHeightPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("line-height: 220%;", source_location_);

  scoped_refptr<cssom::PercentageValue> line_height =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kLineHeightProperty).get());
  ASSERT_TRUE(line_height);
  EXPECT_FLOAT_EQ(2.2f, line_height->value());
}

TEST_F(ParserTest, ParsesMarginWith1Value) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin: auto;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginTopProperty));
  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginRightProperty));
  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginBottomProperty));
  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginLeftProperty));
}

TEST_F(ParserTest, ParsesMarginWith2Values) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin: auto 0;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginTopProperty));

  scoped_refptr<cssom::LengthValue> margin_right =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginRightProperty).get());
  ASSERT_TRUE(margin_right);
  EXPECT_FLOAT_EQ(0, margin_right->value());
  EXPECT_EQ(cssom::kPixelsUnit, margin_right->unit());

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginBottomProperty));

  scoped_refptr<cssom::LengthValue> margin_left =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginLeftProperty).get());
  ASSERT_TRUE(margin_left);
  EXPECT_FLOAT_EQ(0, margin_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, margin_left->unit());
}

TEST_F(ParserTest, ParsesMarginWith3Values) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin: 0 auto 10%;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> margin_top =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginTopProperty).get());
  ASSERT_TRUE(margin_top);
  EXPECT_FLOAT_EQ(0, margin_top->value());
  EXPECT_EQ(cssom::kPixelsUnit, margin_top->unit());

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginRightProperty));

  scoped_refptr<cssom::PercentageValue> margin_bottom =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kMarginBottomProperty).get());
  ASSERT_TRUE(margin_bottom);
  EXPECT_FLOAT_EQ(0.1f, margin_bottom->value());

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginLeftProperty));
}

TEST_F(ParserTest, ParseMarginUnsupportedValue) {
  // Test the case where margin has two warnings. Ensure this doesn't crash
  // releasing a NULL pointer.
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:7: error: non-zero length is "
                      "not allowed without unit identifier"));
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:7: warning: unsupported value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "margin: 1em 1 340282366920938463463374607431768211455;",
          source_location_);
}

TEST_F(ParserTest, ParsesMarginWith4Values) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin: 10px 20px 30px 40px;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> margin_top =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginTopProperty).get());
  ASSERT_TRUE(margin_top);
  EXPECT_FLOAT_EQ(10, margin_top->value());
  EXPECT_EQ(cssom::kPixelsUnit, margin_top->unit());

  scoped_refptr<cssom::LengthValue> margin_right =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginRightProperty).get());
  ASSERT_TRUE(margin_right);
  EXPECT_FLOAT_EQ(20, margin_right->value());
  EXPECT_EQ(cssom::kPixelsUnit, margin_right->unit());

  scoped_refptr<cssom::LengthValue> margin_bottom =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginBottomProperty).get());
  ASSERT_TRUE(margin_bottom);
  EXPECT_FLOAT_EQ(30, margin_bottom->value());
  EXPECT_EQ(cssom::kPixelsUnit, margin_bottom->unit());

  scoped_refptr<cssom::LengthValue> margin_left =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginLeftProperty).get());
  ASSERT_TRUE(margin_left);
  EXPECT_FLOAT_EQ(40, margin_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, margin_left->unit());
}

TEST_F(ParserTest, ParsesMarginBottom) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin-bottom: 1em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> margin_bottom =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMarginBottomProperty).get());
  ASSERT_TRUE(margin_bottom);
  EXPECT_FLOAT_EQ(1, margin_bottom->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, margin_bottom->unit());
}

TEST_F(ParserTest, ParsesMarginLeft) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin-left: 5.5%;", source_location_);

  scoped_refptr<cssom::PercentageValue> margin_left =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kMarginLeftProperty).get());
  ASSERT_TRUE(margin_left);
  EXPECT_FLOAT_EQ(0.055f, margin_left->value());
}

TEST_F(ParserTest, ParsesMarginRight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin-right: auto;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kMarginRightProperty));
}

TEST_F(ParserTest, ParsesMarginTop) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("margin-top: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kMarginTopProperty));
}

TEST_F(ParserTest, ParsesMaxHeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("max-height: 100px;", source_location_);

  scoped_refptr<cssom::LengthValue> max_height =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMaxHeightProperty).get());
  ASSERT_TRUE(max_height);
  EXPECT_FLOAT_EQ(100, max_height->value());
  EXPECT_EQ(cssom::kPixelsUnit, max_height->unit());
}

TEST_F(ParserTest, ParsesMaxHeightNone) {
  // 'none' is also the initial value for max-height. It is set to a length
  // value first, to ensure that the property does not have the initial value
  // for the test.
  //   https://www.w3.org/TR/CSS2/visudet.html#propdef-max-height
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("max-height: 100px; max-height: none;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kMaxHeightProperty));
}

TEST_F(ParserTest, ParsesMaxWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("max-width: 100px;", source_location_);

  scoped_refptr<cssom::LengthValue> max_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMaxWidthProperty).get());
  ASSERT_TRUE(max_width);
  EXPECT_FLOAT_EQ(100, max_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, max_width->unit());
}

TEST_F(ParserTest, ParsesMaxWidthNone) {
  // 'none' is also the initial value for max-width. It is set to a length value
  // first, to ensure that the property does not have the initial value for the
  // test.
  //   https://www.w3.org/TR/CSS2/visudet.html#propdef-max-width
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("max-width: 100px; max-width: none;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kMaxWidthProperty));
}

TEST_F(ParserTest, ParsesMinHeight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("min-height: 100px;", source_location_);

  scoped_refptr<cssom::LengthValue> min_height =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMinHeightProperty).get());
  ASSERT_TRUE(min_height);
  EXPECT_FLOAT_EQ(100, min_height->value());
  EXPECT_EQ(cssom::kPixelsUnit, min_height->unit());
}

TEST_F(ParserTest, ParsesMinWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("min-width: 100px;", source_location_);

  scoped_refptr<cssom::LengthValue> min_width =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kMinWidthProperty).get());
  ASSERT_TRUE(min_width);
  EXPECT_FLOAT_EQ(100, min_width->value());
  EXPECT_EQ(cssom::kPixelsUnit, min_width->unit());
}

TEST_F(ParserTest, ParsesOpacity) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("opacity: 0.5;", source_location_);

  scoped_refptr<cssom::NumberValue> translucent =
      dynamic_cast<cssom::NumberValue*>(
          style->GetPropertyValue(cssom::kOpacityProperty).get());
  ASSERT_TRUE(translucent);
  EXPECT_FLOAT_EQ(0.5f, translucent->value());
}

TEST_F(ParserTest, ClampsOpacityToZero) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("opacity: -3.14;", source_location_);

  scoped_refptr<cssom::NumberValue> transparent =
      dynamic_cast<cssom::NumberValue*>(
          style->GetPropertyValue(cssom::kOpacityProperty).get());
  ASSERT_TRUE(transparent);
  EXPECT_FLOAT_EQ(0, transparent->value());
}

TEST_F(ParserTest, ClampsOpacityToOne) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("opacity: 2.72;", source_location_);

  scoped_refptr<cssom::NumberValue> opaque = dynamic_cast<cssom::NumberValue*>(
      style->GetPropertyValue(cssom::kOpacityProperty).get());
  ASSERT_TRUE(opaque);
  EXPECT_FLOAT_EQ(1, opaque->value());
}

TEST_F(ParserTest, ParsesBreakWordOverflowWrap) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("overflow-wrap: break-word;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetBreakWord(),
            style->GetPropertyValue(cssom::kOverflowWrapProperty));
}

TEST_F(ParserTest, ParsesNormalOverflowWrap) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("overflow-wrap: normal;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNormal(),
            style->GetPropertyValue(cssom::kOverflowWrapProperty));
}

TEST_F(ParserTest, ParsesHiddenOverflow) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("overflow: hidden;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetHidden(),
            style->GetPropertyValue(cssom::kOverflowProperty));
}

TEST_F(ParserTest, ParsesVisibleOverflow) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("overflow: visible;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetVisible(),
            style->GetPropertyValue(cssom::kOverflowProperty));
}

TEST_F(ParserTest, ParsesPaddingWith1Value) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding: inherit;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kPaddingTopProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kPaddingRightProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kPaddingBottomProperty));
  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kPaddingLeftProperty));
}

TEST_F(ParserTest, ParsesPaddingWith2Values) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding: 10% 1.2em;",
                                        source_location_);

  scoped_refptr<cssom::PercentageValue> padding_top =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kPaddingTopProperty).get());
  ASSERT_TRUE(padding_top);
  EXPECT_FLOAT_EQ(0.1f, padding_top->value());

  scoped_refptr<cssom::LengthValue> padding_right =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingRightProperty).get());
  ASSERT_TRUE(padding_right);
  EXPECT_FLOAT_EQ(1.2f, padding_right->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, padding_right->unit());

  scoped_refptr<cssom::PercentageValue> padding_bottom =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kPaddingBottomProperty).get());
  ASSERT_TRUE(padding_bottom);
  EXPECT_FLOAT_EQ(0.1f, padding_bottom->value());

  scoped_refptr<cssom::LengthValue> padding_left =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingLeftProperty).get());
  ASSERT_TRUE(padding_left);
  EXPECT_FLOAT_EQ(1.2f, padding_left->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, padding_left->unit());
}

TEST_F(ParserTest, ParsesPaddingWith3Values) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding: 10% 1.2em 20%;",
                                        source_location_);

  scoped_refptr<cssom::PercentageValue> padding_top =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kPaddingTopProperty).get());
  ASSERT_TRUE(padding_top);
  EXPECT_FLOAT_EQ(0.1f, padding_top->value());

  scoped_refptr<cssom::LengthValue> padding_right =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingRightProperty).get());
  ASSERT_TRUE(padding_right);
  EXPECT_FLOAT_EQ(1.2f, padding_right->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, padding_right->unit());

  scoped_refptr<cssom::PercentageValue> padding_bottom =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kPaddingBottomProperty).get());
  ASSERT_TRUE(padding_bottom);
  EXPECT_FLOAT_EQ(0.2f, padding_bottom->value());

  scoped_refptr<cssom::LengthValue> padding_left =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingLeftProperty).get());
  ASSERT_TRUE(padding_left);
  EXPECT_FLOAT_EQ(1.2f, padding_left->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, padding_left->unit());
}

TEST_F(ParserTest, ParsesPaddingWith4Values) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding: 10px 20px 30px 40px;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> padding_top =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingTopProperty).get());
  ASSERT_TRUE(padding_top);
  EXPECT_FLOAT_EQ(10, padding_top->value());
  EXPECT_EQ(cssom::kPixelsUnit, padding_top->unit());

  scoped_refptr<cssom::LengthValue> padding_right =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingRightProperty).get());
  ASSERT_TRUE(padding_right);
  EXPECT_FLOAT_EQ(20, padding_right->value());
  EXPECT_EQ(cssom::kPixelsUnit, padding_right->unit());

  scoped_refptr<cssom::LengthValue> padding_bottom =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingBottomProperty).get());
  ASSERT_TRUE(padding_bottom);
  EXPECT_FLOAT_EQ(30, padding_bottom->value());
  EXPECT_EQ(cssom::kPixelsUnit, padding_bottom->unit());

  scoped_refptr<cssom::LengthValue> padding_left =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingLeftProperty).get());
  ASSERT_TRUE(padding_left);
  EXPECT_FLOAT_EQ(40, padding_left->value());
  EXPECT_EQ(cssom::kPixelsUnit, padding_left->unit());
}

TEST_F(ParserTest, ParsesPaddingBottom) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding-bottom: 1em;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> padding_bottom =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kPaddingBottomProperty).get());
  ASSERT_TRUE(padding_bottom);
  EXPECT_FLOAT_EQ(1, padding_bottom->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, padding_bottom->unit());
}

TEST_F(ParserTest, ParsesPaddingLeft) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding-left: 5.5%;",
                                        source_location_);

  scoped_refptr<cssom::PercentageValue> padding_left =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kPaddingLeftProperty).get());
  ASSERT_TRUE(padding_left);
  EXPECT_FLOAT_EQ(0.055f, padding_left->value());
}

TEST_F(ParserTest, ParsesPaddingRight) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding-right: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kPaddingRightProperty));
}

TEST_F(ParserTest, ParsesPaddingTop) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("padding-top: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kPaddingTopProperty));
}

TEST_F(ParserTest, ParsesStaticPosition) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("position: static;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetStatic(),
            style->GetPropertyValue(cssom::kPositionProperty));
}

TEST_F(ParserTest, ParsesRelativePosition) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("position: relative;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetRelative(),
            style->GetPropertyValue(cssom::kPositionProperty));
}

TEST_F(ParserTest, ParsesAbsolutePosition) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("position: absolute;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAbsolute(),
            style->GetPropertyValue(cssom::kPositionProperty));
}

TEST_F(ParserTest, ParsesNoneTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: none;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kTransformProperty));
}

TEST_F(ParserTest, ParsesRotateTransformInDegrees) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: rotate(180deg);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::RotateFunction* rotate_function =
      dynamic_cast<const cssom::RotateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(rotate_function);
  EXPECT_FLOAT_EQ(static_cast<float>(M_PI),
                  rotate_function->clockwise_angle_in_radians());
}

TEST_F(ParserTest, ParsesRotateTransformInGradians) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: rotate(200grad);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::RotateFunction* rotate_function =
      dynamic_cast<const cssom::RotateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(rotate_function);
  EXPECT_FLOAT_EQ(static_cast<float>(M_PI),
                  rotate_function->clockwise_angle_in_radians());
}

TEST_F(ParserTest, ParsesRotateTransformInRadians) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transform: rotate(3.141592653589793rad);", source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::RotateFunction* rotate_function =
      dynamic_cast<const cssom::RotateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(rotate_function);
  EXPECT_FLOAT_EQ(static_cast<float>(M_PI),
                  rotate_function->clockwise_angle_in_radians());
}

TEST_F(ParserTest, ParsesRotateTransformInTurns) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: rotate(0.5turn);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::RotateFunction* rotate_function =
      dynamic_cast<const cssom::RotateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(rotate_function);
  EXPECT_FLOAT_EQ(static_cast<float>(M_PI),
                  rotate_function->clockwise_angle_in_radians());
}

TEST_F(ParserTest, ParsesIsotropicScaleTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: scale(1.5);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::ScaleFunction* scale_function =
      dynamic_cast<const cssom::ScaleFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(scale_function);
  EXPECT_FLOAT_EQ(1.5, scale_function->x_factor());
  EXPECT_FLOAT_EQ(1.5, scale_function->y_factor());
}

TEST_F(ParserTest, ParsesIsotropicScaleXTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: scaleX(0.5);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::ScaleFunction* scale_function =
      dynamic_cast<const cssom::ScaleFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(scale_function);
  EXPECT_FLOAT_EQ(0.5, scale_function->x_factor());
  EXPECT_FLOAT_EQ(1.0, scale_function->y_factor());
}

TEST_F(ParserTest, ParsesIsotropicScaleYTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: scaleY(20);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::ScaleFunction* scale_function =
      dynamic_cast<const cssom::ScaleFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(scale_function);
  EXPECT_FLOAT_EQ(1.0, scale_function->x_factor());
  EXPECT_FLOAT_EQ(20.0, scale_function->y_factor());
}

// TODO: Test integers, including negative ones.
// TODO: Test reals, including negative ones.
// TODO: Test non-zero lengths without units.

TEST_F(ParserTest, ParsesAnisotropicScaleTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: scale(16, 9);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::ScaleFunction* scale_function =
      dynamic_cast<const cssom::ScaleFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(scale_function);
  EXPECT_FLOAT_EQ(16, scale_function->x_factor());
  EXPECT_FLOAT_EQ(9, scale_function->y_factor());
}

TEST_F(ParserTest, Parses2DTranslateTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translate(-50%, 30px);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(2, transform_list->value().size());

  const cssom::TranslateFunction* translate_function_1 =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function_1);

  ASSERT_EQ(cssom::TranslateFunction::kPercentage,
            translate_function_1->offset_type());
  scoped_refptr<cssom::PercentageValue> offset_1 =
      translate_function_1->offset_as_percentage();
  EXPECT_FLOAT_EQ(-0.5f, offset_1->value());
  EXPECT_EQ(cssom::TranslateFunction::kXAxis, translate_function_1->axis());

  const cssom::TranslateFunction* translate_function_2 =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[1]);
  ASSERT_TRUE(translate_function_2);

  ASSERT_EQ(cssom::TranslateFunction::kLength,
            translate_function_2->offset_type());
  scoped_refptr<cssom::LengthValue> offset_2 =
      translate_function_2->offset_as_length();
  EXPECT_FLOAT_EQ(30, offset_2->value());
  EXPECT_EQ(cssom::kPixelsUnit, offset_2->unit());
  EXPECT_EQ(cssom::TranslateFunction::kYAxis, translate_function_2->axis());
}

TEST_F(ParserTest, Parses2DTranslateTransformYOmitted) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translate(20%);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(2, transform_list->value().size());

  const cssom::TranslateFunction* translate_function_1 =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function_1);

  ASSERT_EQ(cssom::TranslateFunction::kPercentage,
            translate_function_1->offset_type());
  scoped_refptr<cssom::PercentageValue> offset_1 =
      translate_function_1->offset_as_percentage();
  EXPECT_FLOAT_EQ(0.2f, offset_1->value());
  EXPECT_EQ(cssom::TranslateFunction::kXAxis, translate_function_1->axis());

  const cssom::TranslateFunction* translate_function_2 =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[1]);
  ASSERT_TRUE(translate_function_2);

  ASSERT_EQ(cssom::TranslateFunction::kLength,
            translate_function_2->offset_type());
  scoped_refptr<cssom::LengthValue> offset_2 =
      translate_function_2->offset_as_length();
  EXPECT_FLOAT_EQ(0, offset_2->value());
  EXPECT_EQ(cssom::kPixelsUnit, offset_2->unit());
  EXPECT_EQ(cssom::TranslateFunction::kYAxis, translate_function_2->axis());
}

TEST_F(ParserTest, ParsesTranslateXTransformLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translateX(0);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::TranslateFunction* translate_function =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function);

  ASSERT_EQ(cssom::TranslateFunction::kLength,
            translate_function->offset_type());
  scoped_refptr<cssom::LengthValue> offset =
      translate_function->offset_as_length();
  EXPECT_FLOAT_EQ(0, offset->value());
  EXPECT_EQ(cssom::kPixelsUnit, offset->unit());
  EXPECT_EQ(cssom::TranslateFunction::kXAxis, translate_function->axis());
}

TEST_F(ParserTest, ParsesTranslateXTransformPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translateX(20%);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::TranslateFunction* translate_function =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function);

  ASSERT_EQ(cssom::TranslateFunction::kPercentage,
            translate_function->offset_type());
  scoped_refptr<cssom::PercentageValue> offset =
      translate_function->offset_as_percentage();
  EXPECT_FLOAT_EQ(0.2f, offset->value());
  EXPECT_EQ(cssom::TranslateFunction::kXAxis, translate_function->axis());
}

TEST_F(ParserTest, ParsesTranslateYTransformLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translateY(30em);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::TranslateFunction* translate_function =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function);

  ASSERT_EQ(cssom::TranslateFunction::kLength,
            translate_function->offset_type());
  scoped_refptr<cssom::LengthValue> offset =
      translate_function->offset_as_length();
  EXPECT_FLOAT_EQ(30, offset->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, offset->unit());
  EXPECT_EQ(cssom::TranslateFunction::kYAxis, translate_function->axis());
}

TEST_F(ParserTest, ParsesTranslateYTransformPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translateY(30%);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::TranslateFunction* translate_function =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function);

  ASSERT_EQ(cssom::TranslateFunction::kPercentage,
            translate_function->offset_type());
  scoped_refptr<cssom::PercentageValue> offset =
      translate_function->offset_as_percentage();
  EXPECT_FLOAT_EQ(0.3f, offset->value());
  EXPECT_EQ(cssom::TranslateFunction::kYAxis, translate_function->axis());
}

TEST_F(ParserTest, ParsesTranslateZTransformLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translateZ(-22px);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::TranslateFunction* translate_function =
      dynamic_cast<const cssom::TranslateFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(translate_function);

  ASSERT_EQ(cssom::TranslateFunction::kLength,
            translate_function->offset_type());
  scoped_refptr<cssom::LengthValue> offset =
      translate_function->offset_as_length();
  EXPECT_FLOAT_EQ(-22, offset->value());
  EXPECT_EQ(cssom::kPixelsUnit, offset->unit());
  EXPECT_EQ(cssom::TranslateFunction::kZAxis, translate_function->axis());
}

TEST_F(ParserTest, ParsesMatrixTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: matrix(1, 2, 3, 4, 5, 6);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(1, transform_list->value().size());

  const cssom::MatrixFunction* matrix_function =
      dynamic_cast<const cssom::MatrixFunction*>(transform_list->value()[0]);
  ASSERT_TRUE(matrix_function);

  EXPECT_FLOAT_EQ(1.0f, matrix_function->value().Get(0, 0));
  EXPECT_FLOAT_EQ(3.0f, matrix_function->value().Get(0, 1));
  EXPECT_FLOAT_EQ(5.0f, matrix_function->value().Get(0, 2));
  EXPECT_FLOAT_EQ(2.0f, matrix_function->value().Get(1, 0));
  EXPECT_FLOAT_EQ(4.0f, matrix_function->value().Get(1, 1));
  EXPECT_FLOAT_EQ(6.0f, matrix_function->value().Get(1, 2));
  EXPECT_FLOAT_EQ(0.0f, matrix_function->value().Get(2, 0));
  EXPECT_FLOAT_EQ(0.0f, matrix_function->value().Get(2, 1));
  EXPECT_FLOAT_EQ(1.0f, matrix_function->value().Get(2, 2));
}

TEST_F(ParserTest, ParsesMultipleTransforms) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: scale(2) translateZ(10px);",
                                        source_location_);

  scoped_refptr<cssom::TransformFunctionListValue> transform_list =
      dynamic_cast<cssom::TransformFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransformProperty).get());
  ASSERT_TRUE(transform_list);
  ASSERT_EQ(2, transform_list->value().size());
  EXPECT_TRUE(transform_list->value()[0]);
  EXPECT_EQ(base::GetTypeId<cssom::ScaleFunction>(),
            transform_list->value()[0]->GetTypeId());
  EXPECT_TRUE(transform_list->value()[1]);
  EXPECT_EQ(base::GetTypeId<cssom::TranslateFunction>(),
            transform_list->value()[1]->GetTypeId());
}

TEST_F(ParserTest, ParsesTranslateXTransformWithoutUnit) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:12: error: non-zero length is "
                      "not allowed without unit identifier"));
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:12: warning: invalid transform "
                        "function"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform: translateX(20);",
                                        source_location_);

  EXPECT_FALSE(style->GetPropertyValue(cssom::kTransformProperty));
}

TEST_F(ParserTest, ParsesTransformOriginWithOneValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform-origin: 20%;",
                                        source_location_);
  scoped_refptr<cssom::PropertyListValue> transform_origin =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTransformOriginProperty).get());
  ASSERT_TRUE(transform_origin);
  ASSERT_EQ(1, transform_origin->value().size());

  const cssom::PercentageValue* horizontal_value =
      dynamic_cast<const cssom::PercentageValue*>(
          transform_origin->value()[0].get());
  EXPECT_FLOAT_EQ(0.2f, horizontal_value->value());
}

TEST_F(ParserTest, ParsesTransformOriginWithOneKeywordValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform-origin: bottom;",
                                        source_location_);
  scoped_refptr<cssom::PropertyListValue> transform_origin =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTransformOriginProperty).get());
  ASSERT_TRUE(transform_origin);
  ASSERT_EQ(1, transform_origin->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetBottom(), transform_origin->value()[0]);
}

TEST_F(ParserTest, ParsesTransformOriginWithTwoValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform-origin: 20% 50%;",
                                        source_location_);
  scoped_refptr<cssom::PropertyListValue> transform_origin =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTransformOriginProperty).get());
  ASSERT_TRUE(transform_origin);
  ASSERT_EQ(2, transform_origin->value().size());

  float expected_value[2] = {0.2f, 0.5f};
  for (size_t i = 0; i < 2; ++i) {
    const cssom::PercentageValue* percentage_value =
        dynamic_cast<const cssom::PercentageValue*>(
            transform_origin->value()[i].get());
    EXPECT_FLOAT_EQ(expected_value[i], percentage_value->value());
  }
}

TEST_F(ParserTest, ParsesTransformOriginWithTwoKeywordValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform-origin: bottom left;",
                                        source_location_);
  scoped_refptr<cssom::PropertyListValue> transform_origin =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTransformOriginProperty).get());
  ASSERT_TRUE(transform_origin);
  ASSERT_EQ(2, transform_origin->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetBottom(), transform_origin->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetLeft(), transform_origin->value()[1]);
}

TEST_F(ParserTest, ParsesTransformOriginWithThreeValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform-origin: left 0.4em 20px;",
                                        source_location_);
  scoped_refptr<cssom::PropertyListValue> transform_origin =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTransformOriginProperty).get());
  ASSERT_TRUE(transform_origin);
  ASSERT_EQ(3, transform_origin->value().size());

  EXPECT_EQ(cssom::KeywordValue::GetLeft(), transform_origin->value()[0]);

  const cssom::LengthValue* vertical_value =
      dynamic_cast<const cssom::LengthValue*>(
          transform_origin->value()[1].get());
  EXPECT_FLOAT_EQ(0.4f, vertical_value->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, vertical_value->unit());

  const cssom::LengthValue* z_value = dynamic_cast<const cssom::LengthValue*>(
      transform_origin->value()[2].get());
  EXPECT_FLOAT_EQ(20.0f, z_value->value());
  EXPECT_EQ(cssom::kPixelsUnit, z_value->unit());
}

TEST_F(ParserTest, ParsesInvalidTransformOrigin) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:23: warning: invalid transform-origin value"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transform-origin: 20% left;",
                                        source_location_);
}

TEST_F(ParserTest, RecoversFromInvalidTransformList) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:25: warning: invalid transform function"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transform: scale(0.001) warp(spacetime);\n"
          "color: #000;\n",
          source_location_);

  EXPECT_TRUE(style->GetPropertyValue(cssom::kColorProperty));
}

TEST_F(ParserTest, ParsesLeftTextAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-align: left;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetLeft(),
            style->GetPropertyValue(cssom::kTextAlignProperty));
}

TEST_F(ParserTest, ParsesCenterTextAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-align: center;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetCenter(),
            style->GetPropertyValue(cssom::kTextAlignProperty));
}

TEST_F(ParserTest, ParsesEndTextAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-align: end;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetEnd(),
            style->GetPropertyValue(cssom::kTextAlignProperty));
}

TEST_F(ParserTest, ParsesRightTextAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-align: right;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetRight(),
            style->GetPropertyValue(cssom::kTextAlignProperty));
}

TEST_F(ParserTest, ParsesTextDecorationColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "text-decoration-color: rgba(0, 0, 0, .8);", source_location_);

  scoped_refptr<cssom::RGBAColorValue> text_decoration_color =
      dynamic_cast<cssom::RGBAColorValue*>(
          style->GetPropertyValue(cssom::kTextDecorationColorProperty).get());
  ASSERT_TRUE(text_decoration_color);
  EXPECT_EQ(0x000000cc, text_decoration_color->value());
}

TEST_F(ParserTest, ParsesTextDecorationLineNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-decoration-line: none;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kTextDecorationLineProperty));
}

TEST_F(ParserTest, ParsesTextDecorationLineLineThrough) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-decoration-line: line-through;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetLineThrough(),
            style->GetPropertyValue(cssom::kTextDecorationLineProperty));
}

TEST_F(ParserTest, ParsesTextDecorationLineInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-decoration-line: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kTextDecorationLineProperty));
}

TEST_F(ParserTest, ParsesTextDecorationShorthandPropertyNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-decoration: none;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kTextDecorationLineProperty));
}

TEST_F(ParserTest, ParsesTextDecorationShorthandPropertyLineThrough) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-decoration: line-through;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetLineThrough(),
            style->GetPropertyValue(cssom::kTextDecorationLineProperty));
}

TEST_F(ParserTest, ParsesTextDecorationShorthandPropertyInitial) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-decoration: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kTextDecorationLineProperty));
}

TEST_F(ParserTest, ParsesStartTextAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-align: start;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetStart(),
            style->GetPropertyValue(cssom::kTextAlignProperty));
}

TEST_F(ParserTest, ParseZeroLengthTextIndent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-indent: 0;", source_location_);

  scoped_refptr<cssom::LengthValue> text_indent =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kTextIndentProperty).get());
  ASSERT_TRUE(text_indent);
  EXPECT_FLOAT_EQ(0, text_indent->value());
  EXPECT_EQ(cssom::kPixelsUnit, text_indent->unit());
}

TEST_F(ParserTest, ParseRelativeLengthTextIndent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-indent: 4em", source_location_);

  scoped_refptr<cssom::LengthValue> text_indent =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kTextIndentProperty).get());
  ASSERT_TRUE(text_indent);
  EXPECT_FLOAT_EQ(4, text_indent->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, text_indent->unit());
}

TEST_F(ParserTest, ParseAbsoluteLengthTextIndent) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-indent: 100px;",
                                        source_location_);

  scoped_refptr<cssom::LengthValue> text_indent =
      dynamic_cast<cssom::LengthValue*>(
          style->GetPropertyValue(cssom::kTextIndentProperty).get());
  ASSERT_TRUE(text_indent);
  EXPECT_FLOAT_EQ(100, text_indent->value());
  EXPECT_EQ(cssom::kPixelsUnit, text_indent->unit());
}

TEST_F(ParserTest, ParsesClipTextOverflow) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-overflow: clip;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetClip(),
            style->GetPropertyValue(cssom::kTextOverflowProperty));
}

TEST_F(ParserTest, ParsesEllipsisTextOverflow) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-overflow: ellipsis;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetEllipsis(),
            style->GetPropertyValue(cssom::kTextOverflowProperty));
}

TEST_F(ParserTest, ParsesTextShadowWithNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-shadow: none;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kTextShadowProperty));
}

TEST_F(ParserTest, ParsesTextShadowWith2Lengths) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-shadow: 0.04em 1px;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> text_shadow_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTextShadowProperty).get());

  EXPECT_EQ(1, text_shadow_list->value().size());
  scoped_refptr<cssom::ShadowValue> text_shadow =
      dynamic_cast<cssom::ShadowValue*>(text_shadow_list->value()[0].get());
  ASSERT_TRUE(text_shadow);
  EXPECT_TRUE(text_shadow->offset_x());
  EXPECT_TRUE(text_shadow->offset_y());
  EXPECT_FALSE(text_shadow->blur_radius());
  EXPECT_FALSE(text_shadow->spread_radius());

  EXPECT_FLOAT_EQ(.04f, text_shadow->offset_x()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, text_shadow->offset_x()->unit());

  EXPECT_FLOAT_EQ(1, text_shadow->offset_y()->value());
  EXPECT_EQ(cssom::kPixelsUnit, text_shadow->offset_y()->unit());

  EXPECT_FALSE(text_shadow->color());
  EXPECT_FALSE(text_shadow->has_inset());
}

TEST_F(ParserTest, ParsesTextShadowWith3LengthsAndColor) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-shadow: 0.04em 1px .2em #123;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> text_shadow_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTextShadowProperty).get());

  EXPECT_EQ(1, text_shadow_list->value().size());
  scoped_refptr<cssom::ShadowValue> text_shadow =
      dynamic_cast<cssom::ShadowValue*>(text_shadow_list->value()[0].get());
  ASSERT_TRUE(text_shadow);
  EXPECT_TRUE(text_shadow->offset_x());
  EXPECT_TRUE(text_shadow->offset_y());
  EXPECT_TRUE(text_shadow->blur_radius());
  EXPECT_FALSE(text_shadow->spread_radius());

  EXPECT_FLOAT_EQ(.04f, text_shadow->offset_x()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, text_shadow->offset_x()->unit());

  EXPECT_FLOAT_EQ(1, text_shadow->offset_y()->value());
  EXPECT_EQ(cssom::kPixelsUnit, text_shadow->offset_y()->unit());

  EXPECT_FLOAT_EQ(.2f, text_shadow->blur_radius()->value());
  EXPECT_EQ(cssom::kFontSizesAkaEmUnit, text_shadow->blur_radius()->unit());

  ASSERT_TRUE(text_shadow->color());
  EXPECT_EQ(0x112233ff, text_shadow->color()->value());

  EXPECT_FALSE(text_shadow->has_inset());
}

TEST_F(ParserTest, ParsesTextShadowWithCommaSeparatedList) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "text-shadow: .2em 20px .3em rgba(0, 0, 0, 0.4), "
          "12px 20px .5em rgba(0, 0, 0, .8);",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> text_shadow_list =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kTextShadowProperty).get());

  EXPECT_EQ(2, text_shadow_list->value().size());

  float expected_length_value[2][3] = {{0.2f, 20.0f, 0.3f},
                                       {12.0f, 20.0f, 0.5f}};
  cssom::LengthUnit expected_length_unit[2][3] = {
      {cssom::kFontSizesAkaEmUnit, cssom::kPixelsUnit,
       cssom::kFontSizesAkaEmUnit},
      {cssom::kPixelsUnit, cssom::kPixelsUnit, cssom::kFontSizesAkaEmUnit}};

  float expected_color[2] = {0x00000066, 0x000000cc};

  for (size_t i = 0; i < text_shadow_list->value().size(); ++i) {
    scoped_refptr<cssom::ShadowValue> text_shadow =
        dynamic_cast<cssom::ShadowValue*>(text_shadow_list->value()[i].get());
    ASSERT_TRUE(text_shadow);

    for (size_t j = 0; j < cssom::ShadowValue::kMaxLengths; ++j) {
      scoped_refptr<cssom::LengthValue> length = text_shadow->lengths()[j];
      if (length) {
        EXPECT_FLOAT_EQ(expected_length_value[i][j], length->value());
        EXPECT_EQ(expected_length_unit[i][j], length->unit());
      }
    }

    scoped_refptr<cssom::RGBAColorValue> color =
        dynamic_cast<cssom::RGBAColorValue*>(text_shadow->color().get());
    ASSERT_TRUE(color);
    EXPECT_EQ(expected_color[i], color->value());

    EXPECT_FALSE(text_shadow->has_inset());
  }
}

TEST_F(ParserTest, ParsesTextShadowWithWrongFormat) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning(
          "[object ParserTest]:1:12: warning: invalid text shadow property."));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "text-shadow: 0.04em 1px .2em 4px "
          "#123;",
          source_location_);
}

TEST_F(ParserTest, ParsesNoneTextTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-transform: none;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kTextTransformProperty));
}

TEST_F(ParserTest, ParsesUppercaseTextTransform) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("text-transform: uppercase;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetUppercase(),
            style->GetPropertyValue(cssom::kTextTransformProperty));
}

TEST_F(ParserTest, ParsesBaselineVerticalAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("vertical-align: baseline;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetBaseline(),
            style->GetPropertyValue(cssom::kVerticalAlignProperty));
}

TEST_F(ParserTest, ParsesBottomVerticalAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("vertical-align: bottom;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetBottom(),
            style->GetPropertyValue(cssom::kVerticalAlignProperty));
}

TEST_F(ParserTest, ParsesMiddleVerticalAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("vertical-align: middle;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetMiddle(),
            style->GetPropertyValue(cssom::kVerticalAlignProperty));
}

TEST_F(ParserTest, ParsesTopVerticalAlign) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("vertical-align: top;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetTop(),
            style->GetPropertyValue(cssom::kVerticalAlignProperty));
}

TEST_F(ParserTest, ParsesHiddenVisibility) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("visibility: hidden;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetHidden(),
            style->GetPropertyValue(cssom::kVisibilityProperty));
}

TEST_F(ParserTest, ParsesVisibleVisibility) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("visibility: visible;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetVisible(),
            style->GetPropertyValue(cssom::kVisibilityProperty));
}

TEST_F(ParserTest, ParsesNormalWhiteSpace) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("white-space: normal;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNormal(),
            style->GetPropertyValue(cssom::kWhiteSpaceProperty));
}

TEST_F(ParserTest, ParsesNoWrapWhiteSpace) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("white-space: nowrap;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetNoWrap(),
            style->GetPropertyValue(cssom::kWhiteSpaceProperty));
}

TEST_F(ParserTest, ParsesPreWhiteSpace) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("white-space: pre;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetPre(),
            style->GetPropertyValue(cssom::kWhiteSpaceProperty));
}

TEST_F(ParserTest, ParsesPreLineWhiteSpace) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("white-space: pre-line;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetPreLine(),
            style->GetPropertyValue(cssom::kWhiteSpaceProperty));
}

TEST_F(ParserTest, ParsesPreWrapWhiteSpace) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("white-space: pre-wrap;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetPreWrap(),
            style->GetPropertyValue(cssom::kWhiteSpaceProperty));
}

TEST_F(ParserTest, ParsesInheritWhiteSpace) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("white-space: inherit;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInherit(),
            style->GetPropertyValue(cssom::kWhiteSpaceProperty));
}

TEST_F(ParserTest, ParsesInitialWhiteSpace) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("white-space: initial;",
                                        source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetInitial(),
            style->GetPropertyValue(cssom::kWhiteSpaceProperty));
}

TEST_F(ParserTest, ParsesWidth) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("width: 100px;", source_location_);

  scoped_refptr<cssom::LengthValue> width = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kWidthProperty).get());
  ASSERT_TRUE(width);
  EXPECT_FLOAT_EQ(100, width->value());
  EXPECT_EQ(cssom::kPixelsUnit, width->unit());
}

TEST_F(ParserTest, ParsesBreakWordWordWrap) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("word-wrap: break-word;",
                                        source_location_);

  // word-wrap is treated as an alias for overflow-wrap
  //   https://www.w3.org/TR/css-text-3/#overflow-wrap
  EXPECT_EQ(cssom::KeywordValue::GetBreakWord(),
            style->GetPropertyValue(cssom::kOverflowWrapProperty));
}

TEST_F(ParserTest, ParsesNormalWordWrap) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("word-wrap: normal;", source_location_);

  // word-wrap is treated as an alias for overflow-wrap
  //   https://www.w3.org/TR/css-text-3/#overflow-wrap
  EXPECT_EQ(cssom::KeywordValue::GetNormal(),
            style->GetPropertyValue(cssom::kOverflowWrapProperty));
}

TEST_F(ParserTest, ParsesValidPropertyValue) {
  scoped_refptr<cssom::RGBAColorValue> color =
      dynamic_cast<cssom::RGBAColorValue*>(
          parser_.ParsePropertyValue("color", "#c0ffee", source_location_)
              .get());
  EXPECT_TRUE(color);
}

TEST_F(ParserTest, WarnsAboutImportantInPropertyValue) {
  EXPECT_CALL(
      parser_observer_,
      OnWarning("[object ParserTest]:1:1: warning: !important is not allowed "
                "when setting single property values."));

  scoped_refptr<cssom::PropertyValue> null_value = parser_.ParsePropertyValue(
      "color", "#f0000d !important", source_location_);
  EXPECT_FALSE(null_value);
}

TEST_F(ParserTest, FailsIfPropertyValueHasTrailingSemicolon) {
  EXPECT_CALL(
      parser_observer_,
      OnError("[object ParserTest]:1:8: error: unrecoverable syntax error"));

  scoped_refptr<cssom::PropertyValue> null_value =
      parser_.ParsePropertyValue("color", "#baaaad;", source_location_);
  EXPECT_FALSE(null_value);
}

TEST_F(ParserTest, WarnsAboutInvalidPropertyValue) {
  EXPECT_CALL(parser_observer_,
              OnWarning("[object ParserTest]:1:1: warning: unsupported value"));

  scoped_refptr<cssom::PropertyValue> null_value =
      parser_.ParsePropertyValue("color", "spring grass", source_location_);
  EXPECT_FALSE(null_value);
}

TEST_F(ParserTest, ParsesKeyframesRule) {
  scoped_refptr<cssom::CSSRule> rule = parser_.ParseRule(
      "@keyframes foo {"
      "  from {"
      "    opacity: 0.25;"
      "  }"
      "  25%, 75% {"
      "    opacity: 0.5;"
      "  }"
      "  to {"
      "    opacity: 0.75;"
      "  }"
      "}",
      source_location_);

  cssom::CSSKeyframesRule* keyframes_rule =
      dynamic_cast<cssom::CSSKeyframesRule*>(rule.get());
  ASSERT_TRUE(keyframes_rule);
  EXPECT_EQ("foo", keyframes_rule->name());

  ASSERT_EQ(3, keyframes_rule->css_rules()->length());

  cssom::CSSKeyframeRule* from_keyframe_rule =
      dynamic_cast<cssom::CSSKeyframeRule*>(
          keyframes_rule->css_rules()->Item(0).get());
  ASSERT_TRUE(from_keyframe_rule);
  ASSERT_EQ(1, from_keyframe_rule->offsets().size());
  EXPECT_EQ(0.0f, from_keyframe_rule->offsets()[0]);
  cssom::NumberValue* from_opacity_value = dynamic_cast<cssom::NumberValue*>(
      from_keyframe_rule->style()
          ->data()
          ->GetPropertyValue(cssom::kOpacityProperty)
          .get());
  ASSERT_TRUE(from_opacity_value);
  EXPECT_EQ(0.25f, from_opacity_value->value());

  cssom::CSSKeyframeRule* mid_keyframe_rule =
      dynamic_cast<cssom::CSSKeyframeRule*>(
          keyframes_rule->css_rules()->Item(1).get());
  ASSERT_TRUE(mid_keyframe_rule);
  ASSERT_EQ(2, mid_keyframe_rule->offsets().size());
  EXPECT_FLOAT_EQ(0.25f, mid_keyframe_rule->offsets()[0]);
  EXPECT_FLOAT_EQ(0.75f, mid_keyframe_rule->offsets()[1]);
  cssom::NumberValue* mid_opacity_value = dynamic_cast<cssom::NumberValue*>(
      mid_keyframe_rule->style()
          ->data()
          ->GetPropertyValue(cssom::kOpacityProperty)
          .get());
  ASSERT_TRUE(mid_opacity_value);
  EXPECT_EQ(0.5f, mid_opacity_value->value());

  cssom::CSSKeyframeRule* to_keyframe_rule =
      dynamic_cast<cssom::CSSKeyframeRule*>(
          keyframes_rule->css_rules()->Item(2).get());
  ASSERT_TRUE(to_keyframe_rule);
  ASSERT_EQ(1, to_keyframe_rule->offsets().size());
  EXPECT_EQ(1.0f, to_keyframe_rule->offsets()[0]);
  cssom::NumberValue* to_opacity_value = dynamic_cast<cssom::NumberValue*>(
      to_keyframe_rule->style()
          ->data()
          ->GetPropertyValue(cssom::kOpacityProperty)
          .get());
  ASSERT_TRUE(to_opacity_value);
  EXPECT_EQ(0.75f, to_opacity_value->value());
}

TEST_F(ParserTest, ParsesInvalidKeyframesRuleWithInherit) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:2:8: error: keyframe properties "
                      "with initial or inherit are not supported"));

  scoped_refptr<cssom::CSSRule> rule = parser_.ParseRule(
      "@keyframes foo {\n"
      "  from { opacity: inherit; }\n"
      "  25%, 75% { opacity: 0.5; }\n"
      "  to { opacity: 0.75; }\n"
      "}",
      source_location_);

  EXPECT_FALSE(rule);
}

TEST_F(ParserTest, ParsesInvalidKeyframesRuleWithInitial) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:4:6: error: keyframe properties "
                      "with initial or inherit are not supported"));

  scoped_refptr<cssom::CSSRule> rule = parser_.ParseRule(
      "@keyframes foo {\n"
      "  from { opacity: 0.2; }\n"
      "  25%, 75% { opacity: 0.5; }\n"
      "  to { opacity: initial; }\n"
      "}",
      source_location_);

  EXPECT_FALSE(rule);
}

TEST_F(ParserTest, IgnoresOtherBrowserKeyframesRules) {
  scoped_refptr<cssom::CSSStyleSheet> style_sheet = parser_.ParseStyleSheet(
      "@-webkit-keyframes foo1 {"
      "  from {"
      "    opacity: 0.6;"
      "  }"
      "  to {"
      "    opacity: 0.8;"
      "  }"
      "}\n"
      "@-o-keyframes foo2 {"
      "  from {"
      "    opacity: 0.3;"
      "  }"
      "  to {"
      "    opacity: 0.4;"
      "  }"
      "}\n"
      "@keyframes foo3 {"
      "  from {"
      "    opacity: 0.25;"
      "  }"
      "  25%, 75% {"
      "    opacity: 0.5;"
      "  }"
      "  to {"
      "    opacity: 0.75;"
      "  }"
      "}",
      source_location_);

  ASSERT_TRUE(style_sheet);
  EXPECT_EQ(1, style_sheet->css_rules()->length());

  cssom::CSSKeyframesRule* keyframes_rule =
      dynamic_cast<cssom::CSSKeyframesRule*>(
          style_sheet->css_rules()->Item(0).get());
  ASSERT_TRUE(keyframes_rule);
  EXPECT_EQ("foo3", keyframes_rule->name());

  ASSERT_EQ(3, keyframes_rule->css_rules()->length());
}

TEST_F(ParserTest, ParsesAnimationDurationWithSingleValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-duration: 1s;",
                                        source_location_);

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_duration =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDurationProperty).get());
  EXPECT_TRUE(animation_duration.get());
  ASSERT_EQ(1, animation_duration->value().size());
  EXPECT_DOUBLE_EQ(1, animation_duration->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesAnimationDelayWithSingleValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-delay: 1s;",
                                        source_location_);

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_delay =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDelayProperty).get());
  EXPECT_TRUE(animation_delay);
  ASSERT_EQ(1, animation_delay->value().size());
  EXPECT_DOUBLE_EQ(1, animation_delay->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesAnimationDirectionWithNormalValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-direction: normal;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_direction =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationDirectionProperty).get());
  EXPECT_TRUE(animation_direction);
  ASSERT_EQ(1, animation_direction->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetNormal(), animation_direction->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationDirectionWithReverseValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-direction: reverse;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_direction =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationDirectionProperty).get());
  EXPECT_TRUE(animation_direction);
  ASSERT_EQ(1, animation_direction->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetReverse(), animation_direction->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationDirectionWithAlternateValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-direction: alternate;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_direction =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationDirectionProperty).get());
  EXPECT_TRUE(animation_direction);
  ASSERT_EQ(1, animation_direction->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetAlternate(),
            animation_direction->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationDirectionWithAlternateReverseValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "animation-direction: alternate-reverse;", source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_direction =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationDirectionProperty).get());
  EXPECT_TRUE(animation_direction);
  ASSERT_EQ(1, animation_direction->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetAlternateReverse(),
            animation_direction->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationDirectionWithListOfValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "animation-direction: normal, alternate;", source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_direction =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationDirectionProperty).get());
  EXPECT_TRUE(animation_direction);
  ASSERT_EQ(2, animation_direction->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetNormal(), animation_direction->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetAlternate(),
            animation_direction->value()[1]);
}

TEST_F(ParserTest, ParsesAnimationDirectionWithInvaildValue) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:22: error: unsupported property "
                      "value for animation-direction"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-direction: foo, alternate;",
                                        source_location_);
  EXPECT_FALSE(style->GetPropertyValue(cssom::kAnimationDirectionProperty));
}

TEST_F(ParserTest, ParsesAnimationFillModeWithForwardsValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-fill-mode: forwards;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_fill_mode =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationFillModeProperty).get());
  EXPECT_TRUE(animation_fill_mode);
  ASSERT_EQ(1, animation_fill_mode->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetForwards(),
            animation_fill_mode->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationFillModeWithBackwardsValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-fill-mode: backwards;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_fill_mode =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationFillModeProperty).get());
  EXPECT_TRUE(animation_fill_mode);
  ASSERT_EQ(1, animation_fill_mode->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetBackwards(),
            animation_fill_mode->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationFillModeWithBothValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-fill-mode: both;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_fill_mode =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationFillModeProperty).get());
  EXPECT_TRUE(animation_fill_mode);
  ASSERT_EQ(1, animation_fill_mode->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetBoth(), animation_fill_mode->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationFillModeWithListOfValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "animation-fill-mode: forwards, backwards, both, none;",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_fill_mode =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationFillModeProperty).get());
  EXPECT_TRUE(animation_fill_mode);
  ASSERT_EQ(4, animation_fill_mode->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetForwards(),
            animation_fill_mode->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetBackwards(),
            animation_fill_mode->value()[1]);
  EXPECT_EQ(cssom::KeywordValue::GetBoth(), animation_fill_mode->value()[2]);
  EXPECT_EQ(cssom::KeywordValue::GetNone(), animation_fill_mode->value()[3]);
}

TEST_F(ParserTest, ParsesAnimationFillModeWithInvalidValues) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:22: error: unsupported property "
                      "value for animation-fill-mode"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-fill-mode: foo, bar, baz;",
                                        source_location_);
  EXPECT_FALSE(style->GetPropertyValue(cssom::kAnimationFillModeProperty));
}

TEST_F(ParserTest, ParsesAnimationIterationCountWithIntegerValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-iteration-count: 2;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_iteration_count =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationIterationCountProperty)
              .get());
  EXPECT_TRUE(animation_iteration_count);
  ASSERT_EQ(1, animation_iteration_count->value().size());
  cssom::NumberValue* number_value =
      base::polymorphic_downcast<cssom::NumberValue*>(
          animation_iteration_count->value()[0].get());
  EXPECT_EQ(2.0f, number_value->value());
}

TEST_F(ParserTest, ParsesAnimationIterationCountWithInfiniteValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-iteration-count: infinite;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_iteration_count =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationIterationCountProperty)
              .get());
  EXPECT_TRUE(animation_iteration_count);
  ASSERT_EQ(1, animation_iteration_count->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetInfinite(),
            animation_iteration_count->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationIterationCountWithMultipleValues) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "animation-iteration-count: 1, infinite, 0.5;", source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_iteration_count =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationIterationCountProperty)
              .get());
  EXPECT_TRUE(animation_iteration_count);
  ASSERT_EQ(3, animation_iteration_count->value().size());
  cssom::NumberValue* first_value =
      base::polymorphic_downcast<cssom::NumberValue*>(
          animation_iteration_count->value()[0].get());
  EXPECT_EQ(1.0f, first_value->value());
  EXPECT_EQ(cssom::KeywordValue::GetInfinite(),
            animation_iteration_count->value()[1]);
  cssom::NumberValue* third_value =
      base::polymorphic_downcast<cssom::NumberValue*>(
          animation_iteration_count->value()[2].get());
  EXPECT_EQ(0.5f, third_value->value());
}

TEST_F(ParserTest, ParsesAnimationIterationCountWithNegativeValues_1) {
  EXPECT_CALL(parser_observer_, OnError("[object ParserTest]:1:28: error: "
                                        "number value must not be negative"));
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:28: error: unsupported property "
                      "value for animation-iteration-count"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-iteration-count: -49, 6;",
                                        source_location_);
  EXPECT_FALSE(
      style->GetPropertyValue(cssom::kAnimationIterationCountProperty));
}

TEST_F(ParserTest, ParsesAnimationIterationCountWithNegativeValues_2) {
  EXPECT_CALL(parser_observer_, OnError("[object ParserTest]:1:31: error: "
                                        "number value must not be negative"));
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:26: error: unsupported property "
                      "value for animation-iteration-count"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-iteration-count: 6, -49;",
                                        source_location_);
  EXPECT_FALSE(
      style->GetPropertyValue(cssom::kAnimationIterationCountProperty));
}

TEST_F(ParserTest, ParsesAnimationIterationCountWithNegativeValues_3) {
  EXPECT_CALL(parser_observer_, OnError("[object ParserTest]:1:28: error: "
                                        "number value must not be negative"));
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:28: error: unsupported property "
                      "value for animation-iteration-count"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-iteration-count: -6, -49;",
                                        source_location_);
  EXPECT_FALSE(
      style->GetPropertyValue(cssom::kAnimationIterationCountProperty));
}

TEST_F(ParserTest, ParsesAnimationNameWithArbitraryName) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-name: foo;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_name =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationNameProperty).get());
  EXPECT_TRUE(animation_name);
  ASSERT_EQ(1, animation_name->value().size());
  cssom::StringValue* name_value =
      base::polymorphic_downcast<cssom::StringValue*>(
          animation_name->value()[0].get());
  EXPECT_EQ("foo", name_value->value());
}

TEST_F(ParserTest, ParsesAnimationNameWithNone) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-name: none;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_name =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationNameProperty).get());
  EXPECT_TRUE(animation_name);
  ASSERT_EQ(1, animation_name->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetNone(), animation_name->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationNameWithMultipleItems) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-name: foo, none, bar;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_name =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationNameProperty).get());
  EXPECT_TRUE(animation_name);
  ASSERT_EQ(3, animation_name->value().size());
  cssom::StringValue* first_value =
      base::polymorphic_downcast<cssom::StringValue*>(
          animation_name->value()[0].get());
  EXPECT_EQ("foo", first_value->value());
  EXPECT_EQ(cssom::KeywordValue::GetNone(), animation_name->value()[1]);
  cssom::StringValue* third_value =
      base::polymorphic_downcast<cssom::StringValue*>(
          animation_name->value()[2].get());
  EXPECT_EQ("bar", third_value->value());
}

TEST_F(ParserTest, ParsesAnimationNameWithMultipleInvalidQuotedItems) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:17: error: unsupported property "
                      "value for animation-name"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "animation-name: \"foo\", none, \'bar\';", source_location_);
  EXPECT_FALSE(style->GetPropertyValue(cssom::kAnimationNameProperty));
}

TEST_F(ParserTest, ParsesAnimationNameWithInvalidValues) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:17: error: unsupported property "
                      "value for animation-name"));
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-name: 24, none, 90px;",
                                        source_location_);
  EXPECT_FALSE(style->GetPropertyValue(cssom::kAnimationNameProperty));
}

namespace {
scoped_refptr<cssom::TimingFunctionListValue> CreateSingleTimingFunctionValue(
    const scoped_refptr<cssom::TimingFunction>& timing_function) {
  scoped_ptr<cssom::TimingFunctionListValue::Builder>
      expected_result_list_builder(
          new cssom::TimingFunctionListValue::Builder());
  expected_result_list_builder->push_back(timing_function);
  return new cssom::TimingFunctionListValue(
      expected_result_list_builder.Pass());
}
}  // namespace

TEST_F(ParserTest, ParsesAnimationTimingFunction) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation-timing-function: linear;",
                                        source_location_);

  scoped_refptr<cssom::TimingFunctionListValue> animation_timing_function =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kAnimationTimingFunctionProperty)
              .get());
  CHECK_NE(static_cast<cssom::TimingFunctionListValue*>(NULL),
           animation_timing_function);

  scoped_refptr<cssom::TimingFunctionListValue> expected_result_list(
      CreateSingleTimingFunctionValue(
          new cssom::CubicBezierTimingFunction(0.0f, 0.0f, 1.0f, 1.0f)));

  EXPECT_TRUE(expected_result_list->Equals(*animation_timing_function));
}

TEST_F(ParserTest, ParsesAnimationShorthandForName) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: foo;", source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_name =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationNameProperty).get());
  EXPECT_TRUE(animation_name);
  ASSERT_EQ(1, animation_name->value().size());
  cssom::StringValue* name_value =
      base::polymorphic_downcast<cssom::StringValue*>(
          animation_name->value()[0].get());
  EXPECT_EQ("foo", name_value->value());
}

TEST_F(ParserTest, ParsesAnimationShorthandForDuration) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: 1s;", source_location_);

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_duration =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDurationProperty).get());
  EXPECT_TRUE(animation_duration);
  ASSERT_EQ(1, animation_duration->value().size());
  EXPECT_DOUBLE_EQ(1.0f, animation_duration->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesAnimationShorthandForDirection) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: reverse;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_direction =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationDirectionProperty).get());
  EXPECT_TRUE(animation_direction);
  ASSERT_EQ(1, animation_direction->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetReverse(), animation_direction->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationShorthandForDurationAndDelay) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: 1s 2s;", source_location_);

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_duration =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDurationProperty).get());
  EXPECT_TRUE(animation_duration);
  ASSERT_EQ(1, animation_duration->value().size());
  EXPECT_DOUBLE_EQ(1.0f, animation_duration->value()[0].InSecondsF());

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_delay =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDelayProperty).get());
  EXPECT_TRUE(animation_delay);
  ASSERT_EQ(1, animation_delay->value().size());
  EXPECT_DOUBLE_EQ(2.0f, animation_delay->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesAnimationShorthandForIterationCount) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: 1.5;", source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_iteration_count =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationIterationCountProperty)
              .get());
  EXPECT_TRUE(animation_iteration_count);
  ASSERT_EQ(1, animation_iteration_count->value().size());
  cssom::NumberValue* number_value =
      base::polymorphic_downcast<cssom::NumberValue*>(
          animation_iteration_count->value()[0].get());
  EXPECT_EQ(1.5f, number_value->value());
}

TEST_F(ParserTest, ParsesAnimationShorthandForTimingFunction) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: linear;", source_location_);

  scoped_refptr<cssom::TimingFunctionListValue> animation_timing_function =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kAnimationTimingFunctionProperty)
              .get());
  CHECK_NE(static_cast<cssom::TimingFunctionListValue*>(NULL),
           animation_timing_function);

  scoped_refptr<cssom::TimingFunctionListValue> expected_result_list(
      CreateSingleTimingFunctionValue(
          new cssom::CubicBezierTimingFunction(0.0f, 0.0f, 1.0f, 1.0f)));

  EXPECT_TRUE(expected_result_list->Equals(*animation_timing_function));
}

TEST_F(ParserTest, ParsesAnimationShorthandForFillMode) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: forwards;",
                                        source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_fill_mode =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationFillModeProperty).get());
  EXPECT_TRUE(animation_fill_mode);
  ASSERT_EQ(1, animation_fill_mode->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetForwards(),
            animation_fill_mode->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationShorthandForAllProperties) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "animation: linear foo 1s 2s 1.5 forwards alternate;",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> animation_fill_mode =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationFillModeProperty).get());
  EXPECT_TRUE(animation_fill_mode);
  ASSERT_EQ(1, animation_fill_mode->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetForwards(),
            animation_fill_mode->value()[0]);

  scoped_refptr<cssom::TimingFunctionListValue> animation_timing_function =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kAnimationTimingFunctionProperty)
              .get());
  CHECK_NE(static_cast<cssom::TimingFunctionListValue*>(NULL),
           animation_timing_function);

  scoped_refptr<cssom::TimingFunctionListValue> expected_result_list(
      CreateSingleTimingFunctionValue(
          new cssom::CubicBezierTimingFunction(0.0f, 0.0f, 1.0f, 1.0f)));

  EXPECT_TRUE(expected_result_list->Equals(*animation_timing_function));

  scoped_refptr<cssom::PropertyListValue> animation_iteration_count =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationIterationCountProperty)
              .get());
  EXPECT_TRUE(animation_iteration_count);
  ASSERT_EQ(1, animation_iteration_count->value().size());
  cssom::NumberValue* number_value =
      base::polymorphic_downcast<cssom::NumberValue*>(
          animation_iteration_count->value()[0].get());
  EXPECT_EQ(1.5f, number_value->value());

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_duration =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDurationProperty).get());
  EXPECT_TRUE(animation_duration);
  ASSERT_EQ(1, animation_duration->value().size());
  EXPECT_DOUBLE_EQ(1.0f, animation_duration->value()[0].InSecondsF());

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_delay =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDelayProperty).get());
  EXPECT_TRUE(animation_delay);
  ASSERT_EQ(1, animation_delay->value().size());
  EXPECT_DOUBLE_EQ(2.0f, animation_delay->value()[0].InSecondsF());

  scoped_refptr<cssom::PropertyListValue> animation_name =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationNameProperty).get());
  EXPECT_TRUE(animation_name);
  ASSERT_EQ(1, animation_name->value().size());
  cssom::StringValue* name_value =
      base::polymorphic_downcast<cssom::StringValue*>(
          animation_name->value()[0].get());
  EXPECT_EQ("foo", name_value->value());

  scoped_refptr<cssom::PropertyListValue> animation_direction =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationDirectionProperty).get());
  EXPECT_TRUE(animation_direction);
  ASSERT_EQ(1, animation_direction->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetAlternate(),
            animation_direction->value()[0]);
}

TEST_F(ParserTest, ParsesAnimationShorthandForMultipleAnimations) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("animation: foo 1s 2s, bar 3s 4;",
                                        source_location_);

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_duration =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDurationProperty).get());
  EXPECT_TRUE(animation_duration);
  ASSERT_EQ(2, animation_duration->value().size());
  EXPECT_DOUBLE_EQ(1.0f, animation_duration->value()[0].InSecondsF());
  EXPECT_DOUBLE_EQ(3.0f, animation_duration->value()[1].InSecondsF());

  scoped_refptr<cssom::ListValue<base::TimeDelta> > animation_delay =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kAnimationDelayProperty).get());
  EXPECT_TRUE(animation_delay);
  ASSERT_EQ(2, animation_delay->value().size());
  EXPECT_DOUBLE_EQ(2.0f, animation_delay->value()[0].InSecondsF());
  EXPECT_DOUBLE_EQ(0.0f, animation_delay->value()[1].InSecondsF());

  scoped_refptr<cssom::PropertyListValue> animation_name =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationNameProperty).get());
  EXPECT_TRUE(animation_name);
  ASSERT_EQ(2, animation_name->value().size());
  cssom::StringValue* first_name_value =
      base::polymorphic_downcast<cssom::StringValue*>(
          animation_name->value()[0].get());
  EXPECT_EQ("foo", first_name_value->value());
  cssom::StringValue* second_name_value =
      base::polymorphic_downcast<cssom::StringValue*>(
          animation_name->value()[1].get());
  EXPECT_EQ("bar", second_name_value->value());

  scoped_refptr<cssom::PropertyListValue> animation_iteration_count =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationIterationCountProperty)
              .get());
  EXPECT_TRUE(animation_iteration_count);
  ASSERT_EQ(2, animation_iteration_count->value().size());
  cssom::NumberValue* first_number_value =
      base::polymorphic_downcast<cssom::NumberValue*>(
          animation_iteration_count->value()[0].get());
  EXPECT_EQ(1.0f, first_number_value->value());
  cssom::NumberValue* second_number_value =
      base::polymorphic_downcast<cssom::NumberValue*>(
          animation_iteration_count->value()[1].get());
  EXPECT_EQ(4.0f, second_number_value->value());

  scoped_refptr<cssom::PropertyListValue> animation_fill_mode =
      dynamic_cast<cssom::PropertyListValue*>(
          style->GetPropertyValue(cssom::kAnimationFillModeProperty).get());
  EXPECT_TRUE(animation_fill_mode);
  ASSERT_EQ(2, animation_fill_mode->value().size());
  EXPECT_EQ(cssom::KeywordValue::GetNone(), animation_fill_mode->value()[0]);
  EXPECT_EQ(cssom::KeywordValue::GetNone(), animation_fill_mode->value()[1]);
}

TEST_F(ParserTest, ParsesAnimatablePropertyNameListWithSingleValue) {
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          parser_.ParsePropertyValue("transition-property", "color",
                                     source_location_)
              .get());
  ASSERT_TRUE(property_name_list);

  ASSERT_EQ(1, property_name_list->value().size());
  EXPECT_EQ(cssom::kColorProperty, property_name_list->value()[0]);
}

TEST_F(ParserTest, ParsesAnimatablePropertyNameListWithMultipleValues) {
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          parser_.ParsePropertyValue("transition-property",
                                     "color, transform , background-color",
                                     source_location_)
              .get());
  ASSERT_TRUE(property_name_list);

  ASSERT_EQ(3, property_name_list->value().size());
  EXPECT_EQ(cssom::kColorProperty, property_name_list->value()[0]);
  EXPECT_EQ(cssom::kTransformProperty, property_name_list->value()[1]);
  EXPECT_EQ(cssom::kBackgroundColorProperty, property_name_list->value()[2]);
}

TEST_F(ParserTest, ParsesTransitionPropertyWithAllValue) {
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          parser_.ParsePropertyValue("transition-property", "all",
                                     source_location_)
              .get());
  ASSERT_TRUE(property_name_list.get());

  ASSERT_EQ(1, property_name_list->value().size());
  EXPECT_EQ(cssom::kAllProperty, property_name_list->value()[0]);
}

TEST_F(ParserTest, ParsesTransitionPropertyWithNoneValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition-property: none;",
                                        source_location_);

  scoped_refptr<cssom::KeywordValue> transition_property =
      dynamic_cast<cssom::KeywordValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  EXPECT_EQ(cssom::KeywordValue::GetNone().get(), transition_property.get());
}

TEST_F(ParserTest, ParseUnsupportedTransitionProperty) {
  EXPECT_CALL(parser_observer_,
              OnError("[object ParserTest]:1:22: error: unsupported property "
                      "value for animation"));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition-property: left, all;",
                                        source_location_);
}

TEST_F(ParserTest, ParsesTimeListWithSingleValue) {
  scoped_refptr<cssom::TimeListValue> time_list_value =
      dynamic_cast<cssom::TimeListValue*>(
          parser_.ParsePropertyValue("transition-duration", "1s",
                                     source_location_).get());
  ASSERT_TRUE(time_list_value.get());

  ASSERT_EQ(1, time_list_value->value().size());
  EXPECT_DOUBLE_EQ(1.0, time_list_value->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesTimeListWithMultipleValues) {
  scoped_refptr<cssom::TimeListValue> time_list_value =
      dynamic_cast<cssom::TimeListValue*>(
          parser_.ParsePropertyValue("transition-duration",
                                     "2s, 1ms, 0, 2ms, 3s, 3ms",
                                     source_location_).get());
  ASSERT_TRUE(time_list_value.get());

  ASSERT_EQ(6, time_list_value->value().size());
  EXPECT_DOUBLE_EQ(2, time_list_value->value()[0].InSecondsF());
  EXPECT_DOUBLE_EQ(0.001, time_list_value->value()[1].InSecondsF());
  EXPECT_DOUBLE_EQ(0, time_list_value->value()[2].InSecondsF());
  EXPECT_DOUBLE_EQ(0.002, time_list_value->value()[3].InSecondsF());
  EXPECT_DOUBLE_EQ(3, time_list_value->value()[4].InSecondsF());
  EXPECT_DOUBLE_EQ(0.003, time_list_value->value()[5].InSecondsF());
}

TEST_F(ParserTest, ParsesNegativeTimeList) {
  scoped_refptr<cssom::TimeListValue> time_list_value =
      dynamic_cast<cssom::TimeListValue*>(
          parser_.ParsePropertyValue("transition-duration", "-4s",
                                     source_location_).get());
  ASSERT_TRUE(time_list_value.get());

  ASSERT_EQ(1, time_list_value->value().size());
  EXPECT_DOUBLE_EQ(-4, time_list_value->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesTransitionDelayWithSingleValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition-delay: 1s;",
                                        source_location_);

  scoped_refptr<cssom::ListValue<base::TimeDelta> > transition_delay =
      dynamic_cast<cssom::ListValue<base::TimeDelta>*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  EXPECT_TRUE(transition_delay.get());
  ASSERT_EQ(1, transition_delay->value().size());
  EXPECT_DOUBLE_EQ(1, transition_delay->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesTransitionDurationWithSingleValue) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition-duration: 1s;",
                                        source_location_);

  scoped_refptr<cssom::TimeListValue> transition_duration =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  EXPECT_TRUE(transition_duration.get());
  ASSERT_EQ(1, transition_duration->value().size());
  EXPECT_DOUBLE_EQ(1, transition_duration->value()[0].InSecondsF());
}

namespace {

// Returns true if the timing function obtained from parsing the passed in
// property declaration string is equal to the passed in expected timing
// function.
bool TestTransitionTimingFunctionKeyword(
    Parser* parser, const base::SourceLocation& source_location,
    const std::string& property_declaration_string,
    const scoped_refptr<cssom::TimingFunction>& expected_result) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser->ParseStyleDeclarationList(
          "transition-timing-function: " + property_declaration_string + ";",
          source_location);

  scoped_refptr<cssom::TimingFunctionListValue> transition_timing_function =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  CHECK_NE(static_cast<cssom::TimingFunctionListValue*>(NULL),
           transition_timing_function.get());

  scoped_refptr<cssom::TimingFunctionListValue> expected_result_list(
      CreateSingleTimingFunctionValue(expected_result));

  return expected_result_list->Equals(*transition_timing_function);
}

}  // namespace

TEST_F(ParserTest, ParsesTransitionTimingFunctionEaseKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "ease",
      new cssom::CubicBezierTimingFunction(0.25f, 0.1f, 0.25f, 1.0f)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionEaseInKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "ease-in",
      new cssom::CubicBezierTimingFunction(0.42f, 0.0f, 1.0f, 1.0f)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionEaseInOutKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "ease-in-out",
      new cssom::CubicBezierTimingFunction(0.42f, 0.0f, 0.58f, 1.0f)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionEaseOutKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "ease-out",
      new cssom::CubicBezierTimingFunction(0.0f, 0.0f, 0.58f, 1.0f)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionLinearKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "linear",
      new cssom::CubicBezierTimingFunction(0.0f, 0.0f, 1.0f, 1.0f)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionStepEndKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "step-end",
      new cssom::SteppingTimingFunction(1,
                                        cssom::SteppingTimingFunction::kEnd)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionStepStartKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "step-start",
      new cssom::SteppingTimingFunction(
          1, cssom::SteppingTimingFunction::kStart)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionArbitraryCubicBezierKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "cubic-bezier(0.1, -2.0, 0.3, 2.0)",
      new cssom::CubicBezierTimingFunction(0.1f, -2.0f, 0.3f, 2.0f)));
}
TEST_F(ParserTest,
       ParsesTransitionTimingFunctionArbitrarySteppingStartKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "steps(2, start)",
      new cssom::SteppingTimingFunction(
          2, cssom::SteppingTimingFunction::kStart)));
}
TEST_F(ParserTest, ParsesTransitionTimingFunctionArbitrarySteppingEndKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "steps(2, end)",
      new cssom::SteppingTimingFunction(2,
                                        cssom::SteppingTimingFunction::kEnd)));
}
TEST_F(ParserTest,
       ParsesTransitionTimingFunctionArbitrarySteppingNoStartOrEndKeyword) {
  EXPECT_TRUE(TestTransitionTimingFunctionKeyword(
      &parser_, source_location_, "steps(2)",
      new cssom::SteppingTimingFunction(2,
                                        cssom::SteppingTimingFunction::kEnd)));
}

TEST_F(ParserTest, ParsesMultipleTransitionTimingFunctions) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transition-timing-function: ease, ease-in, step-start;",
          source_location_);

  scoped_refptr<cssom::TimingFunctionListValue> transition_timing_function =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(transition_timing_function.get());

  scoped_ptr<cssom::TimingFunctionListValue::Builder>
      expected_result_list_builder(
          new cssom::TimingFunctionListValue::Builder());
  expected_result_list_builder->push_back(
      cssom::TimingFunction::GetEase().get());
  expected_result_list_builder->push_back(
      cssom::TimingFunction::GetEaseIn().get());
  expected_result_list_builder->push_back(
      cssom::TimingFunction::GetStepStart().get());
  scoped_refptr<cssom::TimingFunctionListValue> expected_result_list(
      new cssom::TimingFunctionListValue(expected_result_list_builder.Pass()));

  EXPECT_TRUE(expected_result_list->Equals(*transition_timing_function));
}

TEST_F(ParserTest, AboveRangeCubicBezierP1XParameterProduceError) {
  EXPECT_CALL(parser_observer_,
              OnError(
                  "[object ParserTest]:1:1: error: cubic-bezier control point "
                  "x values must be in the range [0, 1]."));
  scoped_refptr<cssom::PropertyValue> error_value = parser_.ParsePropertyValue(
      "transition-timing-function", "cubic-bezier(2, 0, 0.5, 0)",
      source_location_);
  // Test that the ease function was returned in place of the error function.
  EXPECT_TRUE(error_value->Equals(*CreateSingleTimingFunctionValue(
                                      cssom::TimingFunction::GetEase().get())));
}
TEST_F(ParserTest, BelowRangeCubicBezierP1XParameterProduceError) {
  EXPECT_CALL(parser_observer_,
              OnError(
                  "[object ParserTest]:1:1: error: cubic-bezier control point "
                  "x values must be in the range [0, 1]."));
  scoped_refptr<cssom::PropertyValue> error_value = parser_.ParsePropertyValue(
      "transition-timing-function", "cubic-bezier(-1, 0, 0.5, 0)",
      source_location_);
  // Test that the ease function was returned in place of the error function.
  EXPECT_TRUE(error_value->Equals(*CreateSingleTimingFunctionValue(
                                      cssom::TimingFunction::GetEase().get())));
}
TEST_F(ParserTest, AboveRangeCubicBezierP2XParameterProduceError) {
  EXPECT_CALL(parser_observer_,
              OnError(
                  "[object ParserTest]:1:1: error: cubic-bezier control point "
                  "x values must be in the range [0, 1]."));
  scoped_refptr<cssom::PropertyValue> error_value = parser_.ParsePropertyValue(
      "transition-timing-function", "cubic-bezier(0.5, 0, 2, 0)",
      source_location_);
  // Test that the ease function was returned in place of the error function.
  EXPECT_TRUE(error_value->Equals(*CreateSingleTimingFunctionValue(
                                      cssom::TimingFunction::GetEase().get())));
}
TEST_F(ParserTest, BelowRangeCubicBezierP2XParameterProduceError) {
  EXPECT_CALL(parser_observer_,
              OnError(
                  "[object ParserTest]:1:1: error: cubic-bezier control point "
                  "x values must be in the range [0, 1]."));
  scoped_refptr<cssom::PropertyValue> error_value = parser_.ParsePropertyValue(
      "transition-timing-function", "cubic-bezier(0.5, 0, -1, 0)",
      source_location_);
  // Test that the ease function was returned in place of the error function.
  EXPECT_TRUE(error_value->Equals(*CreateSingleTimingFunctionValue(
                                      cssom::TimingFunction::GetEase().get())));
}

TEST_F(ParserTest, ParsesTransitionShorthandOfMultipleItemsWithNoDefaults) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transition: background-color 1s ease-in 0.5s, "
          "transform 2s ease-out 0.5s;",
          source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(2, property_name_list->value().size());
  EXPECT_EQ(cssom::kBackgroundColorProperty, property_name_list->value()[0]);
  EXPECT_EQ(cssom::kTransformProperty, property_name_list->value()[1]);

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(2, duration_list->value().size());
  EXPECT_DOUBLE_EQ(1, duration_list->value()[0].InSecondsF());
  EXPECT_DOUBLE_EQ(2, duration_list->value()[1].InSecondsF());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(2, timing_function_list->value().size());
  EXPECT_TRUE(timing_function_list->value()[0]->Equals(
      *cssom::TimingFunction::GetEaseIn()));
  EXPECT_TRUE(timing_function_list->value()[1]->Equals(
      *cssom::TimingFunction::GetEaseOut()));

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(2, delay_list->value().size());
  EXPECT_DOUBLE_EQ(0.5, delay_list->value()[0].InSecondsF());
  EXPECT_DOUBLE_EQ(0.5, delay_list->value()[1].InSecondsF());
}

TEST_F(ParserTest,
       ParsesTransitionShorthandOfSingleItemWith1PropertySpecified) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition: background-color;",
                                        source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(1, property_name_list->value().size());
  EXPECT_EQ(cssom::kBackgroundColorProperty, property_name_list->value()[0]);

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(1, duration_list->value().size());
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDurationProperty)
              .get())
          ->value()[0],
      duration_list->value()[0]);

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(1, timing_function_list->value().size());
  EXPECT_TRUE(base::polymorphic_downcast<const cssom::TimingFunctionListValue*>(
                  cssom::GetPropertyInitialValue(
                      cssom::kTransitionTimingFunctionProperty)
                      .get())
                  ->value()[0]
                  ->Equals(*timing_function_list->value()[0]));

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(1, delay_list->value().size());
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDelayProperty).get())
          ->value()[0],
      delay_list->value()[0]);
}

TEST_F(ParserTest,
       ParsesTransitionShorthandOfSingleItemWith2PropertiesSpecified) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition: background-color 1s;",
                                        source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(1, property_name_list->value().size());
  EXPECT_EQ(cssom::kBackgroundColorProperty, property_name_list->value()[0]);

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(1, duration_list->value().size());
  EXPECT_DOUBLE_EQ(1, duration_list->value()[0].InSecondsF());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(1, timing_function_list->value().size());
  EXPECT_TRUE(base::polymorphic_downcast<const cssom::TimingFunctionListValue*>(
                  cssom::GetPropertyInitialValue(
                      cssom::kTransitionTimingFunctionProperty)
                      .get())
                  ->value()[0]
                  ->Equals(*timing_function_list->value()[0]));

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(1, delay_list->value().size());
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDelayProperty).get())
          ->value()[0],
      delay_list->value()[0]);
}

TEST_F(ParserTest,
       ParsesTransitionShorthandOfSingleItemWith3PropertiesSpecified) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transition: background-color 1s ease-in;", source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(1, property_name_list->value().size());
  EXPECT_EQ(cssom::kBackgroundColorProperty, property_name_list->value()[0]);

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(1, duration_list->value().size());
  EXPECT_DOUBLE_EQ(1, duration_list->value()[0].InSecondsF());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(1, timing_function_list->value().size());
  EXPECT_TRUE(timing_function_list->value()[0]->Equals(
      *cssom::TimingFunction::GetEaseIn()));

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(1, delay_list->value().size());
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDelayProperty).get())
          ->value()[0],
      delay_list->value()[0]);
}

TEST_F(
    ParserTest,
    ParsesTransitionShorthandOfSingleItemWith3PropertiesSpecifiedNotInOrder) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transition: ease-in background-color 1s;", source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(1, property_name_list->value().size());
  EXPECT_EQ(cssom::kBackgroundColorProperty, property_name_list->value()[0]);

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(1, duration_list->value().size());
  EXPECT_DOUBLE_EQ(1, duration_list->value()[0].InSecondsF());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(1, timing_function_list->value().size());
  EXPECT_TRUE(timing_function_list->value()[0]->Equals(
      *cssom::TimingFunction::GetEaseIn()));

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(1, delay_list->value().size());
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDelayProperty).get())
          ->value()[0],
      delay_list->value()[0]);
}

TEST_F(ParserTest,
       ParsesTransitionShorthandOfMultipleItemsWith2PropertiesSpecified) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transition: background-color 1s, transform 2s;", source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(2, property_name_list->value().size());
  EXPECT_EQ(cssom::kBackgroundColorProperty, property_name_list->value()[0]);
  EXPECT_EQ(cssom::kTransformProperty, property_name_list->value()[1]);

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(2, duration_list->value().size());
  EXPECT_DOUBLE_EQ(1, duration_list->value()[0].InSecondsF());
  EXPECT_DOUBLE_EQ(2, duration_list->value()[1].InSecondsF());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(2, timing_function_list->value().size());
  EXPECT_TRUE(base::polymorphic_downcast<const cssom::TimingFunctionListValue*>(
                  cssom::GetPropertyInitialValue(
                      cssom::kTransitionTimingFunctionProperty)
                      .get())
                  ->value()[0]
                  ->Equals(*timing_function_list->value()[0]));
  EXPECT_TRUE(base::polymorphic_downcast<const cssom::TimingFunctionListValue*>(
                  cssom::GetPropertyInitialValue(
                      cssom::kTransitionTimingFunctionProperty)
                      .get())
                  ->value()[0]
                  ->Equals(*timing_function_list->value()[1]));

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(2, delay_list->value().size());
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDelayProperty).get())
          ->value()[0],
      delay_list->value()[0]);
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDelayProperty).get())
          ->value()[0],
      delay_list->value()[1]);
}

TEST_F(ParserTest, ParsesTransitionShorthandWithErrorBeforeSemicolon) {
  EXPECT_CALL(parser_observer_, OnError(
                                    "[object ParserTest]:1:16: error: "
                                    "unsupported property value for animation"))
      .Times(AtLeast(1));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transition: 1s voodoo-magic; display: inline;", source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(0, property_name_list->value().size());

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(0, duration_list->value().size());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(0, timing_function_list->value().size());

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(0, delay_list->value().size());

  // Test that despite the error, display inline was still set correctly.
  EXPECT_EQ(cssom::KeywordValue::GetInline(),
            style->GetPropertyValue(cssom::kDisplayProperty));
}

TEST_F(ParserTest, ParsesTransitionShorthandWithErrorBeforeSpace) {
  EXPECT_CALL(parser_observer_, OnError(
                                    "[object ParserTest]:1:16: error: "
                                    "unsupported property value for animation"))
      .Times(AtLeast(1));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition: 1s voodoo-magic 2s;",
                                        source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(0, property_name_list->value().size());

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(0, duration_list->value().size());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(0, timing_function_list->value().size());

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(0, delay_list->value().size());
}

TEST_F(ParserTest,
       ParsesTransitionShorthandIgnoringErrorButProceedingWithNonError) {
  EXPECT_CALL(parser_observer_, OnError(
                                    "[object ParserTest]:1:16: error: "
                                    "unsupported property value for animation"))
      .Times(AtLeast(1));

  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "transition: 1s voodoo-magic, transform 2s;", source_location_);

  // Test transition-property was set properly.
  scoped_refptr<cssom::PropertyKeyListValue> property_name_list =
      dynamic_cast<cssom::PropertyKeyListValue*>(
          style->GetPropertyValue(cssom::kTransitionPropertyProperty).get());
  ASSERT_TRUE(property_name_list.get());
  ASSERT_EQ(1, property_name_list->value().size());
  EXPECT_EQ(cssom::kTransformProperty, property_name_list->value()[0]);

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(1, duration_list->value().size());
  EXPECT_DOUBLE_EQ(2, duration_list->value()[0].InSecondsF());

  // Test transition-timing-function was set properly.
  scoped_refptr<cssom::TimingFunctionListValue> timing_function_list =
      dynamic_cast<cssom::TimingFunctionListValue*>(
          style->GetPropertyValue(cssom::kTransitionTimingFunctionProperty)
              .get());
  ASSERT_TRUE(timing_function_list.get());
  ASSERT_EQ(1, timing_function_list->value().size());
  EXPECT_TRUE(base::polymorphic_downcast<const cssom::TimingFunctionListValue*>(
                  cssom::GetPropertyInitialValue(
                      cssom::kTransitionTimingFunctionProperty)
                      .get())
                  ->value()[0]
                  ->Equals(*timing_function_list->value()[0]));

  // Test transition-delay was set properly.
  scoped_refptr<cssom::TimeListValue> delay_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDelayProperty).get());
  ASSERT_TRUE(delay_list.get());
  ASSERT_EQ(1, delay_list->value().size());
  EXPECT_EQ(
      base::polymorphic_downcast<const cssom::TimeListValue*>(
          cssom::GetPropertyInitialValue(cssom::kTransitionDelayProperty).get())
          ->value()[0],
      delay_list->value()[0]);
}

TEST_F(ParserTest, ParsesTransitionShorthandWithNoneIsValid) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("transition: none 0s;",
                                        source_location_);

  // Test transition-property was set properly.
  EXPECT_EQ(cssom::KeywordValue::GetNone(),
            style->GetPropertyValue(cssom::kTransitionPropertyProperty));

  // Test transition-duration was set properly.
  scoped_refptr<cssom::TimeListValue> duration_list =
      dynamic_cast<cssom::TimeListValue*>(
          style->GetPropertyValue(cssom::kTransitionDurationProperty).get());
  ASSERT_TRUE(duration_list.get());
  ASSERT_EQ(1, duration_list->value().size());
  EXPECT_DOUBLE_EQ(0, duration_list->value()[0].InSecondsF());
}

TEST_F(ParserTest, ParsesLeftWithLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("left: 10px;", source_location_);

  scoped_refptr<cssom::LengthValue> length = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kLeftProperty).get());
  ASSERT_TRUE(length);
  EXPECT_EQ(10, length->value());
  EXPECT_EQ(cssom::kPixelsUnit, length->unit());
}

TEST_F(ParserTest, ParsesLeftWithPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("left: 10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kLeftProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesLeftWithNegativePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("left: -10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kLeftProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(-0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesLeftWithAuto) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("left: auto;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kLeftProperty));
}

TEST_F(ParserTest, ParsesTopWithLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("top: 10px;", source_location_);

  scoped_refptr<cssom::LengthValue> length = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kTopProperty).get());
  ASSERT_TRUE(length);
  EXPECT_EQ(10, length->value());
  EXPECT_EQ(cssom::kPixelsUnit, length->unit());
}

TEST_F(ParserTest, ParsesTopWithPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("top: 10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kTopProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesTopWithNegativePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("top: -10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kTopProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(-0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesTopWithAuto) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("top: auto;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kTopProperty));
}

TEST_F(ParserTest, ParsesRightWithLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("right: 10px;", source_location_);

  scoped_refptr<cssom::LengthValue> length = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kRightProperty).get());
  ASSERT_TRUE(length);
  EXPECT_EQ(10, length->value());
  EXPECT_EQ(cssom::kPixelsUnit, length->unit());
}

TEST_F(ParserTest, ParsesRightWithPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("right: 10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kRightProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesRightWithNegativePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("right: -10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kRightProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(-0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesRightWithAuto) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("right: auto;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kRightProperty));
}

TEST_F(ParserTest, ParsesBottomWithLength) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("bottom: 10px;", source_location_);

  scoped_refptr<cssom::LengthValue> length = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kBottomProperty).get());
  ASSERT_TRUE(length);
  EXPECT_EQ(10, length->value());
  EXPECT_EQ(cssom::kPixelsUnit, length->unit());
}

TEST_F(ParserTest, ParsesBottomWithPercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("bottom: 10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kBottomProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesBottomWithNegativePercentage) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("bottom: -10%;", source_location_);

  scoped_refptr<cssom::PercentageValue> percentage =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kBottomProperty).get());
  ASSERT_TRUE(percentage);
  EXPECT_FLOAT_EQ(-0.1f, percentage->value());
}

TEST_F(ParserTest, ParsesBottomWithAuto) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("bottom: auto;", source_location_);

  EXPECT_EQ(cssom::KeywordValue::GetAuto(),
            style->GetPropertyValue(cssom::kBottomProperty));
}

TEST_F(ParserTest, ParsesZIndex) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("z-index: 3;", source_location_);

  scoped_refptr<cssom::IntegerValue> z_index =
      dynamic_cast<cssom::IntegerValue*>(
          style->GetPropertyValue(cssom::kZIndexProperty).get());
  ASSERT_TRUE(z_index);
  EXPECT_EQ(3, z_index->value());
}

TEST_F(ParserTest, ParsesNegativeZIndex) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList("z-index: -2;", source_location_);

  scoped_refptr<cssom::IntegerValue> z_index =
      dynamic_cast<cssom::IntegerValue*>(
          style->GetPropertyValue(cssom::kZIndexProperty).get());
  ASSERT_TRUE(z_index);
  EXPECT_EQ(-2, z_index->value());
}

// Test that style declarations in a list are parsed in specified order.
//   https://www.w3.org/TR/cssom/#dom-cssstyledeclaration-csstext
TEST_F(ParserTest, ParsesDeclarationsInSpecifiedOrder) {
  scoped_refptr<cssom::CSSDeclaredStyleData> style =
      parser_.ParseStyleDeclarationList(
          "height:20px; width:150em; height:20%; width:160px;",
          source_location_);

  scoped_refptr<cssom::PercentageValue> height =
      dynamic_cast<cssom::PercentageValue*>(
          style->GetPropertyValue(cssom::kHeightProperty).get());
  ASSERT_TRUE(height);
  EXPECT_EQ(0.2f, height->value());

  scoped_refptr<cssom::LengthValue> width = dynamic_cast<cssom::LengthValue*>(
      style->GetPropertyValue(cssom::kWidthProperty).get());
  ASSERT_TRUE(width);
  EXPECT_EQ(160, width->value());
  EXPECT_EQ(cssom::kPixelsUnit, width->unit());
}

TEST_F(ParserTest, ParsesFontFaceFamily) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("font-family: 'Roboto';",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> font_family_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->family().get());
  ASSERT_TRUE(font_family_list);
  EXPECT_EQ(font_family_list->value().size(), 1);

  scoped_refptr<cssom::StringValue> font_family_string =
      dynamic_cast<cssom::StringValue*>(
          font_family_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(font_family_string);
  EXPECT_EQ("Roboto", font_family_string->value());
}

TEST_F(ParserTest, ParsesFontFaceSrcLocalString) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("src: local('Roboto');",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> src_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->src().get());
  ASSERT_TRUE(src_list);
  EXPECT_EQ(src_list->value().size(), 1);

  scoped_refptr<cssom::LocalSrcValue> local_src =
      dynamic_cast<cssom::LocalSrcValue*>(
          src_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(local_src);
  EXPECT_EQ("Roboto", local_src->value());
}

TEST_F(ParserTest, ParsesFontFaceSrcLocalIdentifier) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("src: local(Roboto);",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> src_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->src().get());
  ASSERT_TRUE(src_list);
  EXPECT_EQ(src_list->value().size(), 1);

  scoped_refptr<cssom::LocalSrcValue> local_src =
      dynamic_cast<cssom::LocalSrcValue*>(
          src_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(local_src);
  EXPECT_EQ("Roboto", local_src->value());
}

TEST_F(ParserTest, ParsesFontFaceSrcUrlWithoutFormat) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("src: url('../assets/icons.ttf');",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> src_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->src().get());
  ASSERT_TRUE(src_list);
  EXPECT_EQ(src_list->value().size(), 1);

  scoped_refptr<cssom::UrlSrcValue> url_src = dynamic_cast<cssom::UrlSrcValue*>(
      src_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(url_src);
  EXPECT_EQ("", url_src->format());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(url_src->url().get());
  EXPECT_EQ("../assets/icons.ttf", url_value->value());
}

TEST_F(ParserTest, ParsesFontFaceSrcUrlWithFormat) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList(
          "src: url(../assets/icons.ttf) format('truetype');",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> src_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->src().get());
  ASSERT_TRUE(src_list);
  EXPECT_EQ(src_list->value().size(), 1);

  scoped_refptr<cssom::UrlSrcValue> url_src = dynamic_cast<cssom::UrlSrcValue*>(
      src_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(url_src);
  EXPECT_EQ("truetype", url_src->format());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(url_src->url().get());

  EXPECT_EQ("../assets/icons.ttf", url_value->value());
}

TEST_F(ParserTest, ParsesFontFaceSrcList) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList(
          "src: local(Roboto), "
          "url(../assets/icons.ttf) format('truetype');",
          source_location_);

  scoped_refptr<cssom::PropertyListValue> src_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->src().get());
  ASSERT_TRUE(src_list);
  EXPECT_EQ(src_list->value().size(), 2);

  scoped_refptr<cssom::LocalSrcValue> local_src =
      dynamic_cast<cssom::LocalSrcValue*>(
          src_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(local_src);
  EXPECT_EQ("Roboto", local_src->value());

  scoped_refptr<cssom::UrlSrcValue> url_src = dynamic_cast<cssom::UrlSrcValue*>(
      src_list->get_item_modulo_size(1).get());
  ASSERT_TRUE(url_src);
  EXPECT_EQ("truetype", url_src->format());

  scoped_refptr<cssom::URLValue> url_value =
      dynamic_cast<cssom::URLValue*>(url_src->url().get());
  EXPECT_EQ("../assets/icons.ttf", url_value->value());
}

TEST_F(ParserTest, ParsesFontFaceStyle) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("font-style: italic;",
                                           source_location_);
  EXPECT_EQ(cssom::FontStyleValue::GetItalic(), font_face->style());
}

TEST_F(ParserTest, ParsesFontFaceWeight) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("font-weight: bold;",
                                           source_location_);
  EXPECT_EQ(cssom::FontWeightValue::GetBoldAka700(), font_face->weight());
}

TEST_F(ParserTest, ParsesFontFaceUnicodeRangeSingleValue) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("unicode-range: U+100;",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> unicode_range_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->unicode_range().get());
  ASSERT_TRUE(unicode_range_list);
  EXPECT_EQ(unicode_range_list->value().size(), 1);

  scoped_refptr<cssom::UnicodeRangeValue> unicode_range =
      dynamic_cast<cssom::UnicodeRangeValue*>(
          unicode_range_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(unicode_range);
  ASSERT_TRUE(unicode_range->IsValid());
  EXPECT_EQ(0x100, unicode_range->start());
  EXPECT_EQ(0x100, unicode_range->end());
}

TEST_F(ParserTest, ParsesFontFaceUnicodeRangeSingleRange) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("unicode-range: U+100000-10FFFF;",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> unicode_range_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->unicode_range().get());
  ASSERT_TRUE(unicode_range_list);
  EXPECT_EQ(unicode_range_list->value().size(), 1);

  scoped_refptr<cssom::UnicodeRangeValue> unicode_range =
      dynamic_cast<cssom::UnicodeRangeValue*>(
          unicode_range_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(unicode_range);
  ASSERT_TRUE(unicode_range->IsValid());
  EXPECT_EQ(0x100000, unicode_range->start());
  EXPECT_EQ(0x10FFFF, unicode_range->end());
}

TEST_F(ParserTest, ParsesFontFaceUnicodeRangeSingleWildcardRange) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("unicode-range: U+???;",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> unicode_range_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->unicode_range().get());
  ASSERT_TRUE(unicode_range_list);
  EXPECT_EQ(unicode_range_list->value().size(), 1);

  scoped_refptr<cssom::UnicodeRangeValue> unicode_range =
      dynamic_cast<cssom::UnicodeRangeValue*>(
          unicode_range_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(unicode_range);
  ASSERT_TRUE(unicode_range->IsValid());
  EXPECT_EQ(0x000, unicode_range->start());
  EXPECT_EQ(0xfff, unicode_range->end());
}

TEST_F(ParserTest, ParsesFontFaceUnicodeRangeEndGreaterThanBegin) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList("unicode-range: U+100-0;",
                                           source_location_);

  scoped_refptr<cssom::PropertyListValue> unicode_range_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->unicode_range().get());
  ASSERT_TRUE(unicode_range_list);
  EXPECT_EQ(unicode_range_list->value().size(), 1);

  scoped_refptr<cssom::UnicodeRangeValue> unicode_range =
      dynamic_cast<cssom::UnicodeRangeValue*>(
          unicode_range_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(unicode_range);
  ASSERT_FALSE(unicode_range->IsValid());
  EXPECT_EQ(0x100, unicode_range->start());
  EXPECT_EQ(0x0, unicode_range->end());
}

TEST_F(ParserTest, ParsesFontFaceUnicodeRangeList) {
  scoped_refptr<cssom::CSSFontFaceDeclarationData> font_face =
      parser_.ParseFontFaceDeclarationList(
          "unicode-range: U+10, U+???, U+100000-10ffff;", source_location_);

  scoped_refptr<cssom::PropertyListValue> unicode_range_list =
      dynamic_cast<cssom::PropertyListValue*>(font_face->unicode_range().get());
  ASSERT_TRUE(unicode_range_list);
  EXPECT_EQ(unicode_range_list->value().size(), 3);

  scoped_refptr<cssom::UnicodeRangeValue> unicode_range1 =
      dynamic_cast<cssom::UnicodeRangeValue*>(
          unicode_range_list->get_item_modulo_size(0).get());
  ASSERT_TRUE(unicode_range1);
  ASSERT_TRUE(unicode_range1->IsValid());
  EXPECT_EQ(0x10, unicode_range1->start());
  EXPECT_EQ(0x10, unicode_range1->end());

  scoped_refptr<cssom::UnicodeRangeValue> unicode_range2 =
      dynamic_cast<cssom::UnicodeRangeValue*>(
          unicode_range_list->get_item_modulo_size(1).get());
  ASSERT_TRUE(unicode_range2);
  ASSERT_TRUE(unicode_range2->IsValid());
  EXPECT_EQ(0x000, unicode_range2->start());
  EXPECT_EQ(0xfff, unicode_range2->end());

  scoped_refptr<cssom::UnicodeRangeValue> unicode_range3 =
      dynamic_cast<cssom::UnicodeRangeValue*>(
          unicode_range_list->get_item_modulo_size(2).get());
  ASSERT_TRUE(unicode_range3);
  ASSERT_TRUE(unicode_range3->IsValid());
  EXPECT_EQ(0x100000, unicode_range3->start());
  EXPECT_EQ(0x10ffff, unicode_range3->end());
}

TEST_F(ParserTest, ParsesEmptyMediaQuery) {
  scoped_refptr<cssom::MediaQuery> media_query =
      parser_.ParseMediaQuery("", source_location_).get();
  ASSERT_TRUE(media_query.get());
  ASSERT_EQ(media_query->media_query(), "");
}

TEST_F(ParserTest, ParsesValidMediaQuery) {
  scoped_refptr<cssom::MediaQuery> media_query =
      parser_.ParseMediaQuery("(max-width: 1024px) and (max-height: 512px)",
                              source_location_)
          .get();
  ASSERT_TRUE(media_query.get());
  // TODO: Update when media query serialization is implemented.
  ASSERT_EQ(media_query->media_query(), "");
}

TEST_F(ParserTest, ParsesEmptyMediaList) {
  scoped_refptr<cssom::MediaList> media_list =
      parser_.ParseMediaList("", source_location_).get();
  ASSERT_TRUE(media_list.get());
  ASSERT_EQ(media_list->media_text(), "");
}

TEST_F(ParserTest, ParsesValidMediaList) {
  scoped_refptr<cssom::MediaList> media_list =
      parser_.ParseMediaList("(max-width: 1024px), (max-height: 512px)",
                             source_location_)
          .get();
  ASSERT_TRUE(media_list.get());
  ASSERT_EQ(media_list->length(), 2);

  // TODO: Update when media query serialization is implemented.
  ASSERT_EQ(media_list->media_text(), ", ");
}

}  // namespace css_parser
}  // namespace cobalt