blob: 7a24cc4d5fd136cb6a380309a717f600d6f5bab8 [file] [log] [blame]
/*
* 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/render_tree/node_visitor.h"
#include <string>
#include "cobalt/math/rect_f.h"
#include "cobalt/math/size.h"
#include "cobalt/render_tree/animations/animate_node.h"
#include "cobalt/render_tree/composition_node.h"
#include "cobalt/render_tree/filter_node.h"
#include "cobalt/render_tree/font.h"
#include "cobalt/render_tree/glyph_buffer.h"
#include "cobalt/render_tree/image_node.h"
#include "cobalt/render_tree/matrix_transform_node.h"
#include "cobalt/render_tree/punch_through_video_node.h"
#include "cobalt/render_tree/rect_node.h"
#include "cobalt/render_tree/rect_shadow_node.h"
#include "cobalt/render_tree/text_node.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using cobalt::render_tree::animations::AnimateNode;
using cobalt::render_tree::Brush;
using cobalt::render_tree::BrushVisitor;
using cobalt::render_tree::ColorRGBA;
using cobalt::render_tree::CompositionNode;
using cobalt::render_tree::FilterNode;
using cobalt::render_tree::Font;
using cobalt::render_tree::FontMetrics;
using cobalt::render_tree::GlyphBuffer;
using cobalt::render_tree::Image;
using cobalt::render_tree::ImageNode;
using cobalt::render_tree::MatrixTransformNode;
using cobalt::render_tree::NodeVisitor;
using cobalt::render_tree::OpacityFilter;
using cobalt::render_tree::PunchThroughVideoNode;
using cobalt::render_tree::RectNode;
using cobalt::render_tree::RectShadowNode;
using cobalt::render_tree::TextNode;
class MockNodeVisitor : public NodeVisitor {
public:
MOCK_METHOD1(Visit, void(AnimateNode* animate));
MOCK_METHOD1(Visit, void(CompositionNode* composition));
MOCK_METHOD1(Visit, void(FilterNode* image));
MOCK_METHOD1(Visit, void(ImageNode* image));
MOCK_METHOD1(Visit, void(MatrixTransformNode* matrix_transform_node));
MOCK_METHOD1(Visit, void(PunchThroughVideoNode* punch_through_video_node));
MOCK_METHOD1(Visit, void(RectNode* rect));
MOCK_METHOD1(Visit, void(RectShadowNode* rect_shadow));
MOCK_METHOD1(Visit, void(TextNode* text));
};
TEST(NodeVisitorTest, VisitsComposition) {
scoped_refptr<CompositionNode> composition(
new CompositionNode(CompositionNode::Builder()));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(composition.get()));
composition->Accept(&mock_visitor);
}
TEST(NodeVisitorTest, VisitsFilter) {
scoped_refptr<FilterNode> filter(new FilterNode(OpacityFilter(0.5f), NULL));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(filter.get()));
filter->Accept(&mock_visitor);
}
namespace {
class DummyImage : public Image {
const cobalt::math::Size& GetSize() const OVERRIDE { return size_; }
private:
cobalt::math::Size size_;
};
class DummyBrush : public Brush {
void Accept(BrushVisitor* visitor) const OVERRIDE {
UNREFERENCED_PARAMETER(visitor);
}
base::TypeId GetTypeId() const OVERRIDE {
return base::GetTypeId<DummyBrush>();
}
};
} // namespace
TEST(NodeVisitorTest, VisitsAnimate) {
scoped_refptr<DummyImage> dummy_image = make_scoped_refptr(new DummyImage());
scoped_refptr<ImageNode> dummy_image_node(new ImageNode(dummy_image));
scoped_refptr<AnimateNode> animate_node(new AnimateNode(dummy_image_node));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(animate_node.get()));
animate_node->Accept(&mock_visitor);
}
TEST(NodeVisitorTest, VisitsImage) {
scoped_refptr<DummyImage> image = make_scoped_refptr(new DummyImage());
scoped_refptr<ImageNode> image_node(new ImageNode(image));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(image_node.get()));
image_node->Accept(&mock_visitor);
}
TEST(NodeVisitorTest, VisitsMatrixTransform) {
scoped_refptr<MatrixTransformNode> matrix_transform_node(
new MatrixTransformNode(NULL, cobalt::math::Matrix3F::Identity()));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(matrix_transform_node.get()));
matrix_transform_node->Accept(&mock_visitor);
}
TEST(NodeVisitorTest, VisitsPunchThroughVideo) {
scoped_refptr<PunchThroughVideoNode> punch_through_video_node(
new PunchThroughVideoNode(cobalt::math::RectF()));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(punch_through_video_node.get()));
punch_through_video_node->Accept(&mock_visitor);
}
TEST(NodeVisitorTest, VisitsRect) {
scoped_refptr<RectNode> rect(
new RectNode(cobalt::math::RectF(), scoped_ptr<Brush>(new DummyBrush())));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(rect.get()));
rect->Accept(&mock_visitor);
}
TEST(NodeVisitorTest, VisitsRectShadow) {
scoped_refptr<RectShadowNode> rect_shadow(new RectShadowNode(
cobalt::math::RectF(),
cobalt::render_tree::Shadow(cobalt::math::Vector2dF(1.0f, 1.0f), 1.0f,
ColorRGBA(0, 0, 0, 1.0f))));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(rect_shadow.get()));
rect_shadow->Accept(&mock_visitor);
}
TEST(NodeVisitorTest, VisitsText) {
scoped_refptr<TextNode> text(
new TextNode(cobalt::math::Vector2dF(0, 0),
new GlyphBuffer(cobalt::math::RectF(0, 0, 1, 1)),
ColorRGBA(0.0f, 0.0f, 0.0f)));
MockNodeVisitor mock_visitor;
EXPECT_CALL(mock_visitor, Visit(text.get()));
text->Accept(&mock_visitor);
}