| /* |
| * 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, 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 |
