* Copyright (c) 2020-2022 Huawei Device Co., Ltd.
* 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 "components/root_view.h"
#include "components/ui_canvas.h"
#include "components/ui_view_group.h"
#include "components/ui_view_group.h"
#include <climits>
#include <gtest/gtest.h>
#include "test_resource_config.h"
using namespace testing::ext;
namespace OHOS {
namespace {
const int16_t POS_X = 50;
const int16_t POS_Y = 100;
const uint16_t WIDTH = 100;
const uint16_t HEIGHT = 100;
const int16_t START1_X = 10;
const int16_t START1_Y = 20;
const int16_t LINE1_X = 40;
const int16_t LINE1_Y = 100;
const int16_t LINE2_X = 50;
const int16_t LINE2_Y = 120;
const int16_t CENTER_X = 150;
const int16_t CENTER_Y = 150;
const int16_t RADIUS = 50;
const int16_t START_ANGLE = 30;
const int16_t END_ANGLE = 250;
const int16_t RECT_X = 250;
const int16_t RECT_Y = 50;
const int16_t RECT_WIDTH = 100;
const int16_t RECT_HEIGHT = 50;
const float LINE_OFFSET1 = 10.0;
const float LINE_OFFSET2 = 50.0;
const float LINE_OFFSET3 = 150.0;
const float MITERLIMIT1 = 11.05;
const float MITERLIMIT2 = 4.6;
const float MITERLIMIT3 = -5.6;
const int16_t IMAGE_X = 20;
const int16_t IMAGE_Y = 10;
const uint8_t FONT_SIZE = 15;
const int16_t LETTER_SPACE = 2;
const float SCALE_X = 0.5;
const float SCALE_Y = 0.5;
const float SHEAR_X = -0.5;
const float SHEAR_Y = 0.5;
const float TRANSLATE_X = 30;
const float TRANSLATE_Y = 10;
const float GLOBALALPHA = 0.5;
const int16_t DOUBLENUMBER = 2;
const double START_X = 180.0;
const double START_Y = 140.0;
const double START_R = 10.0;
const double END_X = 150.0;
const double END_Y = 100.0;
const double END_R = 80.0;
const float COLOR_STOP_0 = 0.0;
const float COLOR_STOP_1 = 0.3;
const float COLOR_STOP_2 = 0.6;
const float COLOR_STOP_3 = 1.0;
const float ROTATE = 10;
const int16_t LINE_X = 30;
const int16_t LINE_Y = 70;
}
class TestUICanvas : public UICanvas {
public:
TestUICanvas() {}
virtual ~TestUICanvas() {}
const UICanvasVertices* GetPath() const
{
return vertices_;
}
Point GetStartPos() const
{
float x;
float y;
if (GetPath() != nullptr) {
vertices_->Rewind(0);
vertices_->GenerateVertex(&x, &y);
return { (int16_t)x, (int16_t)y };
} else {
return { COORD_MIN, COORD_MIN };
}
}
Point GetEndPos() const
{
float x;
float y;
if (GetPath() != nullptr) {
vertices_->LastVertex(&x, &y);
return { (int16_t)x, (int16_t)y };
} else {
return { COORD_MIN, COORD_MIN };
}
}
};
class UICanvasTest : public testing::Test {
public:
static void SetUpTestCase() {}
static void TearDownTestCase() {}
void SetUp();
void TearDown();
static Paint* paint_;
static TestUICanvas* canvas_;
};
Paint* UICanvasTest::paint_ = nullptr;
TestUICanvas* UICanvasTest::canvas_ = nullptr;
void UICanvasTest::SetUp()
{
if (paint_ == nullptr) {
paint_ = new Paint();
}
if (canvas_ == nullptr) {
canvas_ = new TestUICanvas();
}
}
void UICanvasTest::TearDown()
{
if (paint_ != nullptr) {
delete paint_;
paint_ = nullptr;
}
if (canvas_ != nullptr) {
delete canvas_;
canvas_ = nullptr;
}
}
* @tc.name: UICanvasSetPaintStyle_001
* @tc.desc: Verify SetStyle function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasSetPaintStyle_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
Paint::PaintStyle paintStyle = Paint::PaintStyle::FILL_STYLE;
paint_->SetStyle(Paint::PaintStyle::FILL_STYLE);
EXPECT_EQ(paint_->GetStyle(), paintStyle);
}
* @tc.name: UICanvasSetStrokeWidth_001
* @tc.desc: Verify SetStrokeWidth function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasSetStrokeWidth_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetStrokeWidth(WIDTH);
EXPECT_EQ(paint_->GetStrokeWidth(), WIDTH);
}
* @tc.name: UICanvasSetStrokeColor_001
* @tc.desc: Verify SetStrokeColor function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasSetStrokeColor_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetStrokeColor(color);
EXPECT_EQ(paint_->GetStrokeColor().full, color.full);
}
* @tc.name: UICanvasSetFillColor_001
* @tc.desc: Verify SetFillColor function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasSetFillColor_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetFillColor(color);
EXPECT_EQ(paint_->GetFillColor().full, color.full);
}
* @tc.name: UICanvasSetOpacity_001
* @tc.desc: Verify SetOpacity function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasSetOpacity_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetOpacity(OPA_OPAQUE);
EXPECT_EQ(paint_->GetOpacity(), OPA_OPAQUE);
}
* @tc.name: UICanvasSetStartPosition_001
* @tc.desc: Verify SetStartPosition function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasSetStartPosition_001, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->SetStartPosition({POS_X, POS_Y});
EXPECT_EQ(canvas_->GetStartPosition().x, POS_X);
EXPECT_EQ(canvas_->GetStartPosition().y, POS_Y);
}
* @tc.name: UICanvasDrawLine_001
* @tc.desc: Verify DrawLine function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasDrawLine_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
RootView* rootView = RootView::GetInstance();
UIViewGroup* viewGroup = static_cast<UIViewGroup*>(rootView);
Paint paint;
Point startPoint = { 0, 50 };
Point endPoint = { 50, 100 };
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawLine(startPoint, endPoint, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, endPoint.x);
EXPECT_EQ(canvas_->GetStartPosition().y, endPoint.y);
viewGroup->Remove(canvas_);
}
* @tc.name: UICanvasDrawCurve_001
* @tc.desc: Verify DrawCurve function, equal.
* @tc.type: FUNC
* @tc.require: AR000DSMPV
*/
HWTEST_F(UICanvasTest, UICanvasDrawCurve_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
RootView* rootView = RootView::GetInstance();
UIViewGroup* viewGroup = static_cast<UIViewGroup*>(rootView);
Paint paint;
Point startPoint = { 100, 100 };
Point endPoint = { 150, 200 };
Point control1Point = { 150, 100 };
Point control2Point = { 150, 100 };
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawCurve(startPoint, control1Point, control2Point, endPoint, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, endPoint.x);
EXPECT_EQ(canvas_->GetStartPosition().y, endPoint.y);
viewGroup->Remove(canvas_);
}
#if defined(ENABLE_CANVAS_EXTEND) && ENABLE_CANVAS_EXTEND
* @tc.name: UICanvasBeginPath_001
* @tc.desc: Verify BeginPath function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasBeginPath_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
EXPECT_EQ(canvas_->GetPath(), nullptr);
canvas_->BeginPath();
EXPECT_NE(canvas_->GetPath(), nullptr);
}
* @tc.name: UICanvasMoveTo_001
* @tc.desc: Verify MoveTo function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasMoveTo_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, START1_X);
EXPECT_EQ(start.y, START1_Y);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, START1_X);
EXPECT_EQ(end.y, START1_Y);
}
* @tc.name: UICanvasLineTo_001
* @tc.desc: Verify LineTo function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasLineTo_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->LineTo({LINE1_X, LINE1_Y});
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, LINE1_X);
EXPECT_EQ(start.y, LINE1_Y);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, LINE1_X);
EXPECT_EQ(end.y, LINE1_Y);
}
#endif
* @tc.name: UICanvasLineTo_002
* @tc.desc: Verify LineTo function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasLineTo_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
canvas_->LineTo({LINE1_X, LINE1_Y});
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, START1_X);
EXPECT_EQ(start.y, START1_Y);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, LINE1_X);
EXPECT_EQ(end.y, LINE1_Y);
canvas_->LineTo({LINE2_X, LINE2_Y});
end = canvas_->GetEndPos();
EXPECT_EQ(end.x, LINE2_X);
EXPECT_EQ(end.y, LINE2_Y);
}
#if defined(GRAPHIC_ENABLE_ARC_FLAG) && GRAPHIC_ENABLE_ARC_FLAG
#if defined(ENABLE_CANVAS_EXTEND) && ENABLE_CANVAS_EXTEND
* @tc.name: UICanvasArcTo_001
* @tc.desc: Verify ArcTo function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasArcTo_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->ArcTo({CENTER_X, CENTER_Y}, RADIUS, START_ANGLE, END_ANGLE);
float sinma = RADIUS * Sin(START_ANGLE);
float cosma = RADIUS * Sin(QUARTER_IN_DEGREE - START_ANGLE);
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, int16_t(CENTER_X + sinma));
EXPECT_EQ(start.y, int16_t(CENTER_Y - cosma));
sinma = RADIUS * Sin(END_ANGLE);
cosma = RADIUS * Sin(QUARTER_IN_DEGREE - END_ANGLE);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, int16_t(CENTER_X + sinma));
EXPECT_EQ(end.y, int16_t(CENTER_Y - cosma));
}
#endif
* @tc.name: UICanvasArcTo_002
* @tc.desc: Verify ArcTo function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasArcTo_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->ArcTo({CENTER_X, CENTER_Y}, RADIUS, START_ANGLE,
START_ANGLE + CIRCLE_IN_DEGREE + QUARTER_IN_DEGREE);
float sinma = RADIUS * Sin(START_ANGLE);
float cosma = RADIUS * Sin(QUARTER_IN_DEGREE - START_ANGLE);
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, int16_t(CENTER_X + sinma));
EXPECT_EQ(start.y, int16_t(CENTER_Y - cosma));
sinma = RADIUS * Sin(END_ANGLE);
cosma = RADIUS * Sin(QUARTER_IN_DEGREE - END_ANGLE);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, start.x);
EXPECT_EQ(end.y, start.y);
}
* @tc.name: UICanvasArcTo_003
* @tc.desc: Verify ArcTo function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasArcTo_003, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
canvas_->ArcTo({CENTER_X, CENTER_Y}, RADIUS, START_ANGLE, END_ANGLE);
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, START1_X);
EXPECT_EQ(start.y, START1_Y);
float sinma = RADIUS * Sin(END_ANGLE);
float cosma = RADIUS * Sin(QUARTER_IN_DEGREE - END_ANGLE);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, int16_t(CENTER_X + sinma));
EXPECT_EQ(end.y, int16_t(CENTER_Y - cosma));
}
#endif
#if defined(ENABLE_CANVAS_EXTEND) && ENABLE_CANVAS_EXTEND
* @tc.name: UICanvasAddRect_001
* @tc.desc: Verify AddRect function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasAddRect_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->AddRect({RECT_X, RECT_Y}, RECT_HEIGHT, RECT_WIDTH);
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, RECT_X);
EXPECT_EQ(start.y, RECT_Y);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, 0);
EXPECT_EQ(end.y, 0);
}
#endif
* @tc.name: UICanvasAddRect_002
* @tc.desc: Verify AddRect function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasAddRect_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
canvas_->LineTo({LINE1_X, LINE1_Y});
canvas_->AddRect({RECT_X, RECT_Y}, RECT_HEIGHT, RECT_WIDTH);
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, START1_X);
EXPECT_EQ(start.y, START1_Y);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, 0);
EXPECT_EQ(end.y, 0);
}
#if defined(ENABLE_CANVAS_EXTEND) && ENABLE_CANVAS_EXTEND
* @tc.name: UICanvasClosePath_001
* @tc.desc: Verify ClosePath function, equal.
* @tc.type: FUNC
* @tc.require: AR000EVN8V
*/
HWTEST_F(UICanvasTest, UICanvasClosePath_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
canvas_->LineTo({LINE1_X, LINE1_Y});
canvas_->ClosePath();
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, START1_X);
EXPECT_EQ(start.y, START1_Y);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, 0);
EXPECT_EQ(end.y, 0);
}
#endif
* @tc.name: UICanvasClosePath_002
* @tc.desc: Verify ClosePath function, equal.
* @tc.type: FUNC
* @tc.require: SR000EVN8R
*/
HWTEST_F(UICanvasTest, UICanvasClosePath_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
canvas_->LineTo({LINE1_X, LINE1_Y});
canvas_->ClosePath();
canvas_->DrawPath(*paint_);
Point start = canvas_->GetStartPos();
EXPECT_EQ(start.x, START1_X);
EXPECT_EQ(start.y, START1_Y);
Point end = canvas_->GetEndPos();
EXPECT_EQ(end.x, 0);
EXPECT_EQ(end.y, 0);
canvas_->BeginPath();
canvas_->LineTo({LINE2_X, LINE2_Y});
canvas_->ClosePath();
start = canvas_->GetStartPos();
EXPECT_EQ(start.x, LINE2_X);
EXPECT_EQ(start.y, LINE2_Y);
end = canvas_->GetEndPos();
EXPECT_EQ(end.x, 0);
EXPECT_EQ(end.y, 0);
}
#if defined(GRAPHIC_ENABLE_LINECAP_FLAG) && GRAPHIC_ENABLE_LINECAP_FLAG
* @tc.name: UICanvasSetLineCap_001
* @tc.desc: Verify SetLineCap function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetLineCap_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetLineCap(LineCap::BUTT_CAP);
EXPECT_EQ(paint_->GetLineCap(), LineCap::BUTT_CAP);
paint_->SetLineCap(LineCap::SQUARE_CAP);
EXPECT_EQ(paint_->GetLineCap(), LineCap::SQUARE_CAP);
paint_->SetLineCap(LineCap::ROUND_CAP);
EXPECT_EQ(paint_->GetLineCap(), LineCap::ROUND_CAP);
}
* @tc.name: UICanvasSetLineCap_002
* @tc.desc: Verify SetLineCap function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetLineCap_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetLineCap(LineCap::ROUND_CAP);
EXPECT_EQ(paint_->GetLineCap(), LineCap::ROUND_CAP);
paint_->SetLineCap(LineCap::BUTT_CAP);
EXPECT_EQ(paint_->GetLineCap(), LineCap::BUTT_CAP);
paint_->SetLineCap(LineCap::SQUARE_CAP);
EXPECT_EQ(paint_->GetLineCap(), LineCap::SQUARE_CAP);
}
#endif
#if defined(GRAPHIC_ENABLE_LINEJOIN_FLAG) && GRAPHIC_ENABLE_LINEJOIN_FLAG
* @tc.name: UICanvasSetLineJoin_001
* @tc.desc: Verify SetLineJoin function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetLineJoin_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetLineJoin(LineJoin::MITER_JOIN);
EXPECT_EQ(paint_->GetLineJoin(), LineJoin::MITER_JOIN);
paint_->SetLineJoin(LineJoin::ROUND_JOIN);
EXPECT_EQ(paint_->GetLineJoin(), LineJoin::ROUND_JOIN);
paint_->SetLineJoin(LineJoin::BEVEL_JOIN);
EXPECT_EQ(paint_->GetLineJoin(), LineJoin::BEVEL_JOIN);
}
* @tc.name: UICanvasSetLineJoin_002
* @tc.desc: Verify SetLineJoin function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetLineJoin_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetLineJoin(LineJoin::MITER_JOIN);
EXPECT_EQ(paint_->GetLineJoin(), LineJoin::MITER_JOIN);
paint_->SetLineJoin(LineJoin::ROUND_JOIN);
EXPECT_EQ(paint_->GetLineJoin(), LineJoin::ROUND_JOIN);
paint_->SetLineJoin(LineJoin::BEVEL_JOIN);
EXPECT_EQ(paint_->GetLineJoin(), LineJoin::BEVEL_JOIN);
}
#endif
#if defined(GRAPHIC_ENABLE_DASH_GENERATE_FLAG) && GRAPHIC_ENABLE_DASH_GENERATE_FLAG
* @tc.name: UICanvasSetLineDashOffset_001
* @tc.desc: Verify SetLineDashOffset function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetLineDashOffset_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetLineDashOffset(LINE_OFFSET1);
EXPECT_EQ(paint_->GetLineDashOffset(), LINE_OFFSET1);
paint_->SetLineDashOffset(LINE_OFFSET2);
EXPECT_EQ(paint_->GetLineDashOffset(), LINE_OFFSET2);
paint_->SetLineDashOffset(LINE_OFFSET3);
EXPECT_EQ(paint_->GetLineDashOffset(), LINE_OFFSET3);
}
* @tc.name: UICanvasSetLineDashOffset_002
* @tc.desc: Verify SetLineDashOffset function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetLineDashOffset_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetLineDashOffset(LINE_OFFSET1);
EXPECT_EQ(paint_->GetLineDashOffset(), LINE_OFFSET1);
paint_->SetLineDashOffset(LINE_OFFSET2);
EXPECT_EQ(paint_->GetLineDashOffset(), LINE_OFFSET2);
paint_->SetLineDashOffset(LINE_OFFSET3);
EXPECT_EQ(paint_->GetLineDashOffset(), LINE_OFFSET3);
}
#endif
#if defined(GRAPHIC_ENABLE_LINEJOIN_FLAG) && GRAPHIC_ENABLE_LINEJOIN_FLAG
* @tc.name: UICanvasMiterLimit_001
* @tc.desc: Verify MiterLimit function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasMiterLimit_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetMiterLimit(MITERLIMIT1);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT1);
paint_->SetMiterLimit(MITERLIMIT2);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT2);
paint_->SetMiterLimit(MITERLIMIT3);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT3);
}
* @tc.name: UICanvasMiterLimit_002
* @tc.desc: Verify MiterLimit function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasMiterLimit_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetMiterLimit(MITERLIMIT1);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT1);
paint_->SetMiterLimit(MITERLIMIT2);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT2);
paint_->SetMiterLimit(MITERLIMIT3);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT3);
}
* @tc.name: UICanvasMiterLimit_003
* @tc.desc: Verify MiterLimit function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasMiterLimit_003, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetMiterLimit(MITERLIMIT1);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT1);
paint_->SetMiterLimit(MITERLIMIT2 + MITERLIMIT1);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT2 + MITERLIMIT1);
paint_->SetMiterLimit(MITERLIMIT3 + MITERLIMIT2);
EXPECT_EQ(paint_->GetMiterLimit(), MITERLIMIT3 + MITERLIMIT2);
}
#endif
#if defined(GRAPHIC_ENABLE_DASH_GENERATE_FLAG) && GRAPHIC_ENABLE_DASH_GENERATE_FLAG
* @tc.name: UICanvasSetLineDash_001
* @tc.desc: Verify SetLineDash function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetLineDash_001, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
const int32_t dashCount = 4;
float dash[dashCount] = {1, 1.5, 2, 2.5};
paint_->SetLineDash(dash, dashCount);
EXPECT_EQ(paint_->GetLineDashCount(), dashCount);
paint_->ClearLineDash();
EXPECT_EQ(paint_->GetLineDashCount(), 0);
paint_->SetLineDash(dash, dashCount);
int32_t dashLen = paint_->GetLineDashCount();
float* dashArr = paint_->GetLineDash();
for (int32_t i = 0; i < dashLen; i++) {
EXPECT_EQ(dashArr[i], dash[i]);
}
EXPECT_EQ(paint_->IsLineDash(), 1);
paint_->ClearLineDash();
EXPECT_EQ(paint_->GetLineDashCount(), 0);
EXPECT_EQ(paint_->IsLineDash(), 0);
}
#endif
#if defined(ENABLE_CANVAS_EXTEND) && ENABLE_CANVAS_EXTEND
* @tc.name: UICanvasStrokeRect_001
* @tc.desc: Verify StrokeRect function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasStrokeRect_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
RootView* rootView = RootView::GetInstance();
UIViewGroup* viewGroup = static_cast<UIViewGroup*>(rootView);
Paint paint;
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->StrokeRect({RECT_X, RECT_Y}, RECT_HEIGHT, RECT_WIDTH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, RECT_X);
EXPECT_EQ(canvas_->GetStartPosition().y, RECT_Y);
viewGroup->Remove(canvas_);
viewGroup->SetPosition(10, 20);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->StrokeRect({0, 0}, RECT_HEIGHT, RECT_WIDTH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, 0);
EXPECT_EQ(canvas_->GetStartPosition().y, 0);
viewGroup->Remove(canvas_);
}
* @tc.name: UICanvasCleanRect_001
* @tc.desc: Verify CleanRect function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasCleanRect_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
RootView* rootView = RootView::GetInstance();
UIViewGroup* viewGroup = static_cast<UIViewGroup*>(rootView);
Paint paint;
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
paint.SetStyle(Paint::PaintStyle::FILL_STYLE);
paint.SetFillColor(Color::Red());
canvas_->DrawRect({RECT_X, RECT_Y}, RECT_HEIGHT, RECT_WIDTH, paint);
viewGroup->Add(canvas_);
canvas_->ClearRect({RECT_X + RECT_X / 2, RECT_Y + RECT_Y / 2},
RECT_HEIGHT / 2, RECT_WIDTH / 2);
EXPECT_EQ(canvas_->GetStartPos().x, RECT_X + RECT_X / 2);
EXPECT_EQ(canvas_->GetStartPos().y, RECT_Y + RECT_Y / 2);
viewGroup->Remove(canvas_);
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
paint.SetStyle(Paint::PaintStyle::FILL_STYLE);
paint.SetFillColor(Color::Blue());
canvas_->StrokeRect({0, 0}, RECT_HEIGHT, RECT_WIDTH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, 0);
EXPECT_EQ(canvas_->GetStartPosition().y, 0);
canvas_->ClearRect({RECT_X - 10, RECT_Y - 10},
RECT_HEIGHT + 10, RECT_WIDTH + 10);
EXPECT_EQ(canvas_->GetStartPos().x, RECT_X - 10);
EXPECT_EQ(canvas_->GetStartPos().y, RECT_Y - 10);
viewGroup->Remove(canvas_);
}
#if defined(GRAPHIC_ENABLE_DRAW_IMAGE_FLAG) && GRAPHIC_ENABLE_DRAW_IMAGE_FLAG
* @tc.name: UICanvasDrawImage_001
* @tc.desc: Verify DrawImage function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasDrawImage_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
RootView* rootView = RootView::GetInstance();
UIViewGroup* viewGroup = static_cast<UIViewGroup*>(rootView);
Paint paint;
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawImage({0, 0}, JPEG_IMAGE_PATH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, 0);
EXPECT_EQ(canvas_->GetStartPosition().y, 0);
canvas_->ClearRect({RECT_X + RECT_X / DOUBLENUMBER, RECT_Y + RECT_Y / DOUBLENUMBER},
RECT_HEIGHT / DOUBLENUMBER, RECT_WIDTH / DOUBLENUMBER);
EXPECT_EQ(canvas_->GetStartPos().x, RECT_X + RECT_X / DOUBLENUMBER);
EXPECT_EQ(canvas_->GetStartPos().y, RECT_Y + RECT_Y / DOUBLENUMBER);
viewGroup->Remove(canvas_);
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawImage({IMAGE_X, IMAGE_Y}, JPEG_IMAGE_PATH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, IMAGE_X);
EXPECT_EQ(canvas_->GetStartPosition().y, IMAGE_Y);
canvas_->DrawImage({IMAGE_X, IMAGE_Y}, JPEG_IMAGE_PATH, paint);
EXPECT_EQ(canvas_->GetStartPosition().x, IMAGE_X);
EXPECT_EQ(canvas_->GetStartPosition().y, IMAGE_Y);
viewGroup->Remove(canvas_);
}
* @tc.name: UICanvasDrawImage_002
* @tc.desc: Verify DrawImage function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasDrawImage_002, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
RootView* rootView = RootView::GetInstance();
UIViewGroup* viewGroup = static_cast<UIViewGroup*>(rootView);
Paint paint;
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawImage({0, 0}, JPEG_IMAGE_PATH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, 0);
EXPECT_EQ(canvas_->GetStartPosition().y, 0);
canvas_->ClearRect({RECT_X + RECT_X / DOUBLENUMBER, RECT_Y + RECT_Y / DOUBLENUMBER},
RECT_HEIGHT / DOUBLENUMBER, RECT_WIDTH / DOUBLENUMBER);
EXPECT_EQ(canvas_->GetStartPos().x, RECT_X + RECT_X / DOUBLENUMBER);
EXPECT_EQ(canvas_->GetStartPos().y, RECT_Y + RECT_Y / DOUBLENUMBER);
viewGroup->Remove(canvas_);
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawImage({IMAGE_X, IMAGE_Y}, PNG_1_PALETTE_IMAGE_PATH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, IMAGE_X);
EXPECT_EQ(canvas_->GetStartPosition().y, IMAGE_Y);
canvas_->DrawImage({IMAGE_X, IMAGE_Y}, PNG_1_PALETTE_IMAGE_PATH, paint);
EXPECT_EQ(canvas_->GetStartPosition().x, IMAGE_X);
EXPECT_EQ(canvas_->GetStartPosition().y, IMAGE_Y);
viewGroup->Remove(canvas_);
}
* @tc.name: UICanvasDrawImage_003
* @tc.desc: Verify DrawImage function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasDrawImage_003, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
RootView* rootView = RootView::GetInstance();
UIViewGroup* viewGroup = static_cast<UIViewGroup*>(rootView);
Paint paint;
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawImage({0, 0}, JPEG_IMAGE_PATH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, 0);
EXPECT_EQ(canvas_->GetStartPosition().y, 0);
canvas_->ClearRect({RECT_X + RECT_X / DOUBLENUMBER, RECT_Y + RECT_Y / DOUBLENUMBER},
RECT_HEIGHT / DOUBLENUMBER, RECT_WIDTH / DOUBLENUMBER);
EXPECT_EQ(canvas_->GetStartPos().x, RECT_X + RECT_X / DOUBLENUMBER);
EXPECT_EQ(canvas_->GetStartPos().y, RECT_Y + RECT_Y / DOUBLENUMBER);
viewGroup->Remove(canvas_);
viewGroup->SetPosition(0, 0);
viewGroup->SetWidth(WIDTH);
viewGroup->SetHeight(HEIGHT);
canvas_->DrawImage({IMAGE_X, IMAGE_Y}, GIF_IMAGE_PATH, paint);
viewGroup->Add(canvas_);
EXPECT_EQ(canvas_->GetStartPosition().x, IMAGE_X);
EXPECT_EQ(canvas_->GetStartPosition().y, IMAGE_Y);
canvas_->DrawImage({IMAGE_X, IMAGE_Y}, GIF_IMAGE_PATH, paint);
EXPECT_EQ(canvas_->GetStartPosition().x, IMAGE_X);
EXPECT_EQ(canvas_->GetStartPosition().y, IMAGE_Y);
viewGroup->Remove(canvas_);
}
#endif
#endif
#if defined(GRAPHIC_ENABLE_DRAW_TEXT_FLAG) && GRAPHIC_ENABLE_DRAW_TEXT_FLAG
* @tc.name: UICanvasStrokeText_001
* @tc.desc: Verify StrokeText function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasStrokeText_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
}
* @tc.name: UICanvasStrokeText_002
* @tc.desc: Verify StrokeText function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasStrokeText_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
canvas_->StrokeText("hello world", {POS_X, POS_Y}, fontStyle, *paint_);
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(canvas_->GetStartPosition().x, POS_X);
EXPECT_EQ(canvas_->GetStartPosition().y, POS_Y);
}
#endif
* @tc.name: UICanvasMeasureText_001
* @tc.desc: Verify MeasureText function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasMeasureText_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
}
* @tc.name: UICanvasMeasureText_001
* @tc.desc: Verify MeasureText function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasMeasureText_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
canvas_->MeasureText("hello world", fontStyle);
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
}
* @tc.name: UICanvasSetScale_001
* @tc.desc: Verify SetScale function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetScale_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Scale(SCALE_X, SCALE_Y);
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetScaleX(), SCALE_X);
EXPECT_EQ(paint_->GetScaleY(), SCALE_Y);
}
* @tc.name: UICanvasSetScale_002
* @tc.desc: Verify SetScale function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetScale_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Scale(SCALE_X, SCALE_Y);
#if defined(GRAPHIC_ENABLE_DRAW_TEXT_FLAG) && GRAPHIC_ENABLE_DRAW_TEXT_FLAG
canvas_->StrokeText("hello world", {POS_X, POS_Y}, fontStyle, *paint_);
#endif
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetScaleX(), SCALE_X);
EXPECT_EQ(paint_->GetScaleY(), SCALE_Y);
}
* @tc.name: UICanvasSetTranslate_001
* @tc.desc: Verify SetTranslate function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetTranslate_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Translate(TRANSLATE_X, TRANSLATE_Y);
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetTranslateX(), TRANSLATE_X);
EXPECT_EQ(paint_->GetTranslateY(), TRANSLATE_Y);
}
* @tc.name: UICanvasSetTranslate_002
* @tc.desc: Verify SetTranslate function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetTranslate_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Translate(TRANSLATE_X, TRANSLATE_Y);
#if defined(GRAPHIC_ENABLE_DRAW_TEXT_FLAG) && GRAPHIC_ENABLE_DRAW_TEXT_FLAG
canvas_->StrokeText("hello world", {POS_X, POS_Y}, fontStyle, *paint_);
#endif
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetTranslateX(), TRANSLATE_X);
EXPECT_EQ(paint_->GetTranslateY(), TRANSLATE_Y);
}
* @tc.name: UICanvasTransform_001
* @tc.desc: Verify Transform function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasTransform_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Transform(SCALE_X, SHEAR_X, SHEAR_Y, SCALE_Y, TRANSLATE_X, TRANSLATE_Y);
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetScaleX(), SCALE_X);
EXPECT_EQ(paint_->GetScaleY(), SCALE_Y);
EXPECT_EQ(paint_->GetTranslateX(), TRANSLATE_X);
EXPECT_EQ(paint_->GetTranslateY(), TRANSLATE_Y);
}
* @tc.name: UICanvasTransform_002
* @tc.desc: Verify Transform function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasTransform_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Transform(SCALE_X, SHEAR_X, SHEAR_Y, SCALE_Y, TRANSLATE_X, TRANSLATE_Y);
#if defined(GRAPHIC_ENABLE_DRAW_TEXT_FLAG) && GRAPHIC_ENABLE_DRAW_TEXT_FLAG
canvas_->StrokeText("hello world", {POS_X, POS_Y}, fontStyle, *paint_);
#endif
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetScaleX(), SCALE_X);
EXPECT_EQ(paint_->GetScaleY(), SCALE_Y);
EXPECT_EQ(paint_->GetTranslateX(), TRANSLATE_X);
EXPECT_EQ(paint_->GetTranslateY(), TRANSLATE_Y);
}
* @tc.name: UICanvasSetTransform_001
* @tc.desc: Verify SetTransform function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetTransform_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->SetTransform(SCALE_X, SHEAR_X, SHEAR_Y, SCALE_Y, TRANSLATE_X, TRANSLATE_Y);
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetScaleX(), SCALE_X);
EXPECT_EQ(paint_->GetScaleY(), SCALE_Y);
EXPECT_EQ(paint_->GetTranslateX(), TRANSLATE_X);
EXPECT_EQ(paint_->GetTranslateY(), TRANSLATE_Y);
}
* @tc.name: UICanvasSetTransform_002
* @tc.desc: Verify SetTransform function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetTransform_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->SetTransform(SCALE_X, SHEAR_X, SHEAR_Y, SCALE_Y, TRANSLATE_X, TRANSLATE_Y);
#if defined(GRAPHIC_ENABLE_DRAW_TEXT_FLAG) && GRAPHIC_ENABLE_DRAW_TEXT_FLAG
canvas_->StrokeText("hello world", {POS_X, POS_Y}, fontStyle, *paint_);
#endif
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetScaleX(), SCALE_X);
EXPECT_EQ(paint_->GetScaleY(), SCALE_Y);
EXPECT_EQ(paint_->GetTranslateX(), TRANSLATE_X);
EXPECT_EQ(paint_->GetTranslateY(), TRANSLATE_Y);
}
* @tc.name: UICanvasGlobalAlpha_001
* @tc.desc: Verify GlobalAlpha function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasGlobalAlpha_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetGlobalAlpha(GLOBALALPHA);
EXPECT_EQ(paint_->GetGlobalAlpha(), GLOBALALPHA);
}
* @tc.name: UICanvasGlobalAlpha_002
* @tc.desc: Verify GlobalAlpha function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasGlobalAlpha_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetStyle(Paint::PaintStyle::STROKE_FILL_STYLE);
paint_->SetFillColor(color);
canvas_->DrawRect({RECT_X, RECT_Y}, RECT_WIDTH, RECT_HEIGHT, *paint_);
paint_->SetStyle(Paint::PaintStyle::FILL_STYLE);
color = Color::Green();
paint_->SetFillColor(color);
paint_->SetGlobalAlpha(GLOBALALPHA);
canvas_->DrawRect({POS_X, POS_Y}, WIDTH, HEIGHT, *paint_);
EXPECT_EQ(paint_->GetGlobalAlpha(), GLOBALALPHA);
}
* @tc.name: UICanvasGetGlobalAlpha_001
* @tc.desc: Verify GetGlobalAlpha function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasGetGlobalAlpha_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetGlobalAlpha(GLOBALALPHA);
EXPECT_EQ(paint_->GetGlobalAlpha(), GLOBALALPHA);
}
* @tc.name: UICanvasGetGlobalAlpha_002
* @tc.desc: Verify GetGlobalAlpha function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasGetGlobalAlpha_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Green();
paint_->SetStyle(Paint::PaintStyle::FILL_STYLE);
paint_->SetFillColor(color);
paint_->SetGlobalAlpha(GLOBALALPHA);
canvas_->DrawRect({POS_X, POS_Y}, WIDTH, HEIGHT, *paint_);
EXPECT_EQ(paint_->GetGlobalAlpha(), GLOBALALPHA);
}
* @tc.name: UICanvasSetGlobalCompositeOperation_001
* @tc.desc: Verify SetGlobalCompositeOperation function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetGlobalCompositeOperation_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetGlobalCompositeOperation(OHOS::COPY);
EXPECT_EQ(paint_->GetGlobalCompositeOperation(), OHOS::COPY);
}
#if defined(ENABLE_CANVAS_EXTEND) && ENABLE_CANVAS_EXTEND
* @tc.name: UICanvasSetGlobalCompositeOperation_002
* @tc.desc: Verify SetGlobalCompositeOperation function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetGlobalCompositeOperation_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetFillColor(Color::Blue());
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
canvas_->LineTo({START1_X, POS_Y});
canvas_->LineTo({POS_X, POS_Y});
canvas_->LineTo({POS_X, START1_Y});
canvas_->ClosePath();
canvas_->FillPath(*paint_);
paint_->SetGlobalCompositeOperation(OHOS::COPY);
paint_->SetFillColor(Color::Green());
canvas_->BeginPath();
canvas_->MoveTo({LINE_X, LINE_X});
canvas_->LineTo({LINE_X, LINE_Y});
canvas_->LineTo({LINE_Y, LINE_Y});
canvas_->LineTo({LINE_Y, LINE_X});
canvas_->ClosePath();
canvas_->FillPath(*paint_);
EXPECT_EQ(paint_->GetGlobalCompositeOperation(), OHOS::COPY);
}
#endif
* @tc.name: UICanvasGetGlobalCompositeOperation_001
* @tc.desc: Verify GetGlobalCompositeOperation function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasGetGlobalCompositeOperation_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetGlobalCompositeOperation(OHOS::SOURCE_OVER);
EXPECT_EQ(paint_->GetGlobalCompositeOperation(), OHOS::SOURCE_OVER);
}
#if defined(ENABLE_CANVAS_EXTEND) && ENABLE_CANVAS_EXTEND
* @tc.name: UICanvasGetGlobalCompositeOperation_002
* @tc.desc: Verify GetGlobalCompositeOperation function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasGetGlobalCompositeOperation_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetFillColor(Color::Blue());
canvas_->BeginPath();
canvas_->MoveTo({LINE_X, LINE_X});
canvas_->LineTo({LINE_X, LINE_Y});
canvas_->LineTo({LINE_Y, LINE_Y});
canvas_->LineTo({LINE_Y, LINE_X});
canvas_->ClosePath();
canvas_->FillPath(*paint_);
paint_->SetGlobalCompositeOperation(OHOS::SOURCE_OVER);
paint_->SetFillColor(Color::Green());
canvas_->BeginPath();
canvas_->MoveTo({START1_X, START1_Y});
canvas_->LineTo({START1_X, POS_Y});
canvas_->LineTo({POS_X, POS_Y});
canvas_->LineTo({POS_X, START1_Y});
canvas_->ClosePath();
canvas_->FillPath(*paint_);
EXPECT_EQ(paint_->GetGlobalCompositeOperation(), OHOS::SOURCE_OVER);
}
#endif
* @tc.name: UICanvasSave_001
* @tc.desc: Verify Save function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSave_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetFillColor(color);
canvas_->Save(*paint_);
EXPECT_EQ(paint_->GetFillColor().full, color.full);
}
* @tc.name: UICanvasSave_002
* @tc.desc: Verify Save function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSave_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetFillColor(color);
canvas_->Save(*paint_);
canvas_->DrawRect({RECT_X, RECT_Y}, RECT_WIDTH, RECT_HEIGHT, *paint_);
*paint_ = canvas_->Restore();
canvas_->DrawRect({POS_X, POS_Y}, WIDTH, HEIGHT, *paint_);
EXPECT_EQ(paint_->GetFillColor().full, color.full);
}
* @tc.name: UICanvasRestore_001
* @tc.desc: Verify Restore function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasRestore_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetFillColor(color);
canvas_->Save(*paint_);
*paint_ = canvas_->Restore();
EXPECT_EQ(paint_->GetFillColor().full, color.full);
}
* @tc.name: UICanvasRestore_002
* @tc.desc: Verify Restore function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasRestore_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetFillColor(color);
canvas_->Save(*paint_);
canvas_->DrawRect({POS_X, POS_Y}, RECT_WIDTH, RECT_HEIGHT, *paint_);
*paint_ = canvas_->Restore();
canvas_->DrawRect({RECT_X, RECT_Y}, WIDTH, HEIGHT, *paint_);
EXPECT_EQ(paint_->GetFillColor().full, color.full);
}
#if defined(GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG) && GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG
HWTEST_F(UICanvasTest, UICanvasShadowColor_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetShadowColor(color);
EXPECT_EQ(paint_->GetShadowColor().full, color.full);
EXPECT_EQ(paint_->HaveShadow(), true);
}
HWTEST_F(UICanvasTest, UICanvasShadowColor_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType color = Color::Red();
paint_->SetShadowColor(color);
EXPECT_EQ(paint_->GetShadowColor().full, color.full);
}
#endif
#if defined(GRAPHIC_ENABLE_BLUR_EFFECT_FLAG) && GRAPHIC_ENABLE_BLUR_EFFECT_FLAG
HWTEST_F(UICanvasTest, UICanvasShadowBlur_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetShadowBlur(RADIUS);
EXPECT_EQ(paint_->GetShadowBlur(), RADIUS);
}
HWTEST_F(UICanvasTest, UICanvasShadowBlur_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetShadowBlur(RADIUS);
EXPECT_EQ(paint_->GetShadowBlur(), RADIUS);
}
#endif
#if defined(GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG) && GRAPHIC_ENABLE_SHADOW_EFFECT_FLAG
HWTEST_F(UICanvasTest, UICanvasShadowOffsetX_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetShadowOffsetX(RADIUS);
EXPECT_EQ(paint_->GetShadowOffsetX(), RADIUS);
}
HWTEST_F(UICanvasTest, UICanvasShadowOffsetX_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetShadowOffsetX(RADIUS);
EXPECT_EQ(paint_->GetShadowOffsetX(), RADIUS);
}
HWTEST_F(UICanvasTest, UICanvasShadowOffsetY_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetShadowOffsetY(RADIUS);
EXPECT_EQ(paint_->GetShadowOffsetY(), RADIUS);
}
HWTEST_F(UICanvasTest, UICanvasShadowOffsetY_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetShadowOffsetY(RADIUS);
EXPECT_EQ(paint_->GetShadowOffsetY(), RADIUS);
}
#endif
#if defined(GRAPHIC_ENABLE_GRADIENT_FILL_FLAG) && GRAPHIC_ENABLE_GRADIENT_FILL_FLAG
HWTEST_F(UICanvasTest, UICanvasCreateLinearGradient_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->createLinearGradient(START_X, START_Y, END_X, END_Y);
paint_->SetStyle(Paint::GRADIENT);
EXPECT_EQ(paint_->GetLinearGradientPoint().x0, START_X);
EXPECT_EQ(paint_->GetLinearGradientPoint().y0, START_Y);
EXPECT_EQ(paint_->GetLinearGradientPoint().x1, END_X);
EXPECT_EQ(paint_->GetLinearGradientPoint().y1, END_Y);
EXPECT_EQ(paint_->GetGradient(), Paint::Gradient::Linear);
}
HWTEST_F(UICanvasTest, UICanvasCreateLinearGradient_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->createLinearGradient(START_X, START_Y, END_X, END_Y);
paint_->SetStyle(Paint::GRADIENT);
EXPECT_EQ(paint_->GetLinearGradientPoint().x0, START_X);
EXPECT_EQ(paint_->GetLinearGradientPoint().y0, START_Y);
EXPECT_EQ(paint_->GetLinearGradientPoint().x1, END_X);
EXPECT_EQ(paint_->GetLinearGradientPoint().y1, END_Y);
}
HWTEST_F(UICanvasTest, UICanvasCreateRadialGradient_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->createRadialGradient(START_X, START_Y, START_R, END_X, END_Y, END_R);
paint_->SetStyle(Paint::GRADIENT);
EXPECT_EQ(paint_->GetRadialGradientPoint().x0, START_X);
EXPECT_EQ(paint_->GetRadialGradientPoint().y0, START_Y);
EXPECT_EQ(paint_->GetRadialGradientPoint().r0, START_R);
EXPECT_EQ(paint_->GetRadialGradientPoint().x1, END_X);
EXPECT_EQ(paint_->GetRadialGradientPoint().y1, END_Y);
EXPECT_EQ(paint_->GetRadialGradientPoint().r1, END_R);
}
HWTEST_F(UICanvasTest, UICanvasCreateRadialGradient_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->createRadialGradient(START_X, START_Y, START_R, END_X, END_Y, END_R);
paint_->SetStyle(Paint::GRADIENT);
EXPECT_EQ(paint_->GetRadialGradientPoint().x0, START_X);
EXPECT_EQ(paint_->GetRadialGradientPoint().y0, START_Y);
EXPECT_EQ(paint_->GetRadialGradientPoint().r0, START_R);
EXPECT_EQ(paint_->GetRadialGradientPoint().x1, END_X);
EXPECT_EQ(paint_->GetRadialGradientPoint().y1, END_Y);
EXPECT_EQ(paint_->GetRadialGradientPoint().r1, END_R);
}
#endif
#if defined(GRAPHIC_ENABLE_PATTERN_FILL_FLAG) && GRAPHIC_ENABLE_PATTERN_FILL_FLAG
HWTEST_F(UICanvasTest, UICanvasCreatePattern_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->CreatePattern(RED_IMAGE_PATH, REPEAT);
EXPECT_EQ(paint_->GetPatternImage(), RED_IMAGE_PATH);
EXPECT_EQ(paint_->GetPatternRepeatMode(), REPEAT);
}
HWTEST_F(UICanvasTest, UICanvasCreatePattern_002, TestSize.Level0)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->CreatePattern(RED_IMAGE_PATH, REPEAT);
EXPECT_EQ(paint_->GetPatternImage(), RED_IMAGE_PATH);
EXPECT_EQ(paint_->GetPatternRepeatMode(), REPEAT);
}
#endif
#if defined(GRAPHIC_ENABLE_GRADIENT_FILL_FLAG) && GRAPHIC_ENABLE_GRADIENT_FILL_FLAG
HWTEST_F(UICanvasTest, UICanvasAddColorStop_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
ColorType colorStop0 = Color::Yellow();
ColorType colorStop1 = Color::White();
ColorType colorStop2 = Color::Green();
ColorType colorStop3 = Color::Blue();
paint_->createLinearGradient(START_X, START_Y, END_X, END_Y);
paint_->addColorStop(COLOR_STOP_0, colorStop0);
paint_->addColorStop(COLOR_STOP_1, colorStop1);
paint_->addColorStop(COLOR_STOP_2, colorStop2);
paint_->addColorStop(COLOR_STOP_3, colorStop3);
List<Paint::StopAndColor> stopAndColor = paint_->getStopAndColor();
EXPECT_EQ(stopAndColor.Head()->data_.stop, COLOR_STOP_0);
EXPECT_EQ(stopAndColor.Head()->data_.color.full, colorStop0.full);
stopAndColor.PopFront();
EXPECT_EQ(stopAndColor.Head()->data_.stop, COLOR_STOP_1);
EXPECT_EQ(stopAndColor.Head()->data_.color.full, colorStop1.full);
stopAndColor.PopFront();
EXPECT_EQ(stopAndColor.Head()->data_.stop, COLOR_STOP_2);
EXPECT_EQ(stopAndColor.Head()->data_.color.full, colorStop2.full);
stopAndColor.PopFront();
EXPECT_EQ(stopAndColor.Head()->data_.stop, COLOR_STOP_3);
EXPECT_EQ(stopAndColor.Head()->data_.color.full, colorStop3.full);
stopAndColor.PopFront();
}
HWTEST_F(UICanvasTest, UICanvasFillStyle_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetStyle(Paint::PaintStyle::GRADIENT);
EXPECT_EQ(paint_->GetStyle(), Paint::PaintStyle::GRADIENT);
paint_->SetStyle(Paint::PaintStyle::PATTERN);
EXPECT_EQ(paint_->GetStyle(), Paint::PaintStyle::PATTERN);
}
HWTEST_F(UICanvasTest, UICanvasStrokeStyle_001, TestSize.Level1)
{
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
paint_->SetStyle(Paint::PaintStyle::GRADIENT);
EXPECT_EQ(paint_->GetStyle(), Paint::PaintStyle::GRADIENT);
paint_->SetStyle(Paint::PaintStyle::PATTERN);
EXPECT_EQ(paint_->GetStyle(), Paint::PaintStyle::PATTERN);
}
#endif
* @tc.name: UICanvasSetRotate_001
* @tc.desc: Verify SetRotate function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetRotate_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Rotate(ROTATE);
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetRotateAngle(), ROTATE);
}
* @tc.name: UICanvasSetRotate_002
* @tc.desc: Verify SetRotate function, equal.
* @tc.type: FUNC
*/
HWTEST_F(UICanvasTest, UICanvasSetRotate_002, TestSize.Level1)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
UICanvas::FontStyle fontStyle;
fontStyle.align = TEXT_ALIGNMENT_CENTER;
fontStyle.direct = TEXT_DIRECT_LTR;
fontStyle.fontName = DEFAULT_VECTOR_FONT_FILENAME;
fontStyle.fontSize = FONT_SIZE;
fontStyle.letterSpace = LETTER_SPACE;
paint_->Rotate(ROTATE);
#if defined(GRAPHIC_ENABLE_DRAW_TEXT_FLAG) && GRAPHIC_ENABLE_DRAW_TEXT_FLAG
canvas_->StrokeText("hello world", {POS_X, POS_Y}, fontStyle, *paint_);
#endif
EXPECT_EQ(fontStyle.align, TEXT_ALIGNMENT_CENTER);
EXPECT_EQ(fontStyle.direct, TEXT_DIRECT_LTR);
EXPECT_EQ(fontStyle.fontName, DEFAULT_VECTOR_FONT_FILENAME);
EXPECT_EQ(fontStyle.fontSize, FONT_SIZE);
EXPECT_EQ(fontStyle.letterSpace, LETTER_SPACE);
EXPECT_EQ(paint_->GetRotateAngle(), ROTATE);
}
* @tc.name: UICanvasInitDash_001
* @tc.desc: Verify InitDash function, equal.
* @tc.type: FUNC
* @tc.require: AR000H8BAB
*/
HWTEST_F(UICanvasTest, UICanvasInitDash_001, TestSize.Level0)
{
if (canvas_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
if (paint_ == nullptr) {
EXPECT_EQ(1, 0);
return;
}
#if defined(GRAPHIC_ENABLE_DASH_GENERATE_FLAG) && GRAPHIC_ENABLE_DASH_GENERATE_FLAG
Paint* paint3 = new Paint();
paint_->InitDash(*paint3);
EXPECT_EQ(paint_->GetLineDash(), nullptr);
delete paint3;
paint3 = nullptr;
#endif
Paint* paint1 = new Paint();
paint1->Init(*paint_);
EXPECT_EQ(paint1->GetChangeFlag(), false);
ColorType color = Color::Red();
paint1->SetStrokeStyle(color);
EXPECT_EQ(paint1->GetStrokeColor().full, color.full);
color = Color::Yellow();
paint1->SetFillStyle(color);
EXPECT_EQ(paint1->GetFillColor().full, color.full);
paint1->SetStrokeStyle(Paint::PaintStyle::GRADIENT);
EXPECT_EQ(paint1->GetStyle(), Paint::PaintStyle::GRADIENT);
paint1->SetFillStyle(Paint::PaintStyle::STROKE_FILL_STYLE);
EXPECT_EQ(paint1->GetStyle(), Paint::PaintStyle::STROKE_FILL_STYLE);
paint1->GetTransAffine();
EXPECT_EQ(paint1->HaveComposite(), false);
delete paint1;
paint1 = nullptr;
}
}