1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16#ifndef TEST_UTILS_H
17#define TEST_UTILS_H
18
19#include <DeviceInfo.h>
20#include <DisplayList.h>
21#include <Matrix.h>
22#include <Rect.h>
23#include <RenderNode.h>
24#include <renderstate/RenderState.h>
25#include <renderthread/RenderThread.h>
26#include <Snapshot.h>
27
28#if HWUI_NEW_OPS
29#include <RecordedOp.h>
30#include <RecordingCanvas.h>
31#else
32#include <DisplayListOp.h>
33#include <DisplayListCanvas.h>
34#endif
35
36#include <memory>
37
38namespace android {
39namespace uirenderer {
40
41#if HWUI_NEW_OPS
42typedef RecordingCanvas TestCanvas;
43#else
44typedef DisplayListCanvas TestCanvas;
45#endif
46
47#define EXPECT_MATRIX_APPROX_EQ(a, b) \
48    EXPECT_TRUE(TestUtils::matricesAreApproxEqual(a, b))
49
50#define EXPECT_RECT_APPROX_EQ(a, b) \
51    EXPECT_TRUE(MathUtils::areEqual(a.left, b.left) \
52            && MathUtils::areEqual(a.top, b.top) \
53            && MathUtils::areEqual(a.right, b.right) \
54            && MathUtils::areEqual(a.bottom, b.bottom));
55
56#define EXPECT_CLIP_RECT(expRect, clipStatePtr) \
57        EXPECT_NE(nullptr, (clipStatePtr)) << "Op is unclipped"; \
58        if ((clipStatePtr)->mode == ClipMode::Rectangle) { \
59            EXPECT_EQ((expRect), reinterpret_cast<const ClipRect*>(clipStatePtr)->rect); \
60        } else { \
61            ADD_FAILURE() << "ClipState not a rect"; \
62        }
63/**
64 * Like gtest's TEST, but runs on the RenderThread, and 'renderThread' is passed, in top level scope
65 * (for e.g. accessing its RenderState)
66 */
67#define RENDERTHREAD_TEST(test_case_name, test_name) \
68    class test_case_name##_##test_name##_RenderThreadTest { \
69    public: \
70        static void doTheThing(renderthread::RenderThread& renderThread); \
71    }; \
72    TEST(test_case_name, test_name) { \
73        TestUtils::runOnRenderThread(test_case_name##_##test_name##_RenderThreadTest::doTheThing); \
74    }; \
75    void test_case_name##_##test_name##_RenderThreadTest::doTheThing(renderthread::RenderThread& renderThread)
76
77/**
78 * Sets a property value temporarily, generally for the duration of a test, restoring the previous
79 * value when going out of scope.
80 *
81 * Can be used e.g. to test behavior only active while Properties::debugOverdraw is enabled.
82 */
83template <typename T>
84class ScopedProperty {
85public:
86    ScopedProperty(T& property, T newValue)
87        : mPropertyPtr(&property)
88        , mOldValue(property) {
89        property = newValue;
90    }
91    ~ScopedProperty() {
92        *mPropertyPtr = mOldValue;
93    }
94private:
95    T* mPropertyPtr;
96    T mOldValue;
97};
98
99class TestUtils {
100public:
101    class SignalingDtor {
102    public:
103        SignalingDtor()
104                : mSignal(nullptr) {}
105        SignalingDtor(int* signal)
106                : mSignal(signal) {}
107        void setSignal(int* signal) {
108            mSignal = signal;
109        }
110        ~SignalingDtor() {
111            if (mSignal) {
112                (*mSignal)++;
113            }
114        }
115    private:
116        int* mSignal;
117    };
118
119    static bool matricesAreApproxEqual(const Matrix4& a, const Matrix4& b) {
120        for (int i = 0; i < 16; i++) {
121            if (!MathUtils::areEqual(a[i], b[i])) {
122                return false;
123            }
124        }
125        return true;
126    }
127
128    static std::unique_ptr<Snapshot> makeSnapshot(const Matrix4& transform, const Rect& clip) {
129        std::unique_ptr<Snapshot> snapshot(new Snapshot());
130        snapshot->clip(clip, SkRegion::kReplace_Op); // store clip first, so it isn't transformed
131        *(snapshot->transform) = transform;
132        return snapshot;
133    }
134
135    static SkBitmap createSkBitmap(int width, int height,
136            SkColorType colorType = kN32_SkColorType) {
137        SkBitmap bitmap;
138        SkImageInfo info = SkImageInfo::Make(width, height,
139                colorType, kPremul_SkAlphaType);
140        bitmap.setInfo(info);
141        bitmap.allocPixels(info);
142        return bitmap;
143    }
144
145    static sp<DeferredLayerUpdater> createTextureLayerUpdater(
146            renderthread::RenderThread& renderThread, uint32_t width, uint32_t height,
147            const SkMatrix& transform);
148
149    template<class CanvasType>
150    static std::unique_ptr<DisplayList> createDisplayList(int width, int height,
151            std::function<void(CanvasType& canvas)> canvasCallback) {
152        CanvasType canvas(width, height);
153        canvasCallback(canvas);
154        return std::unique_ptr<DisplayList>(canvas.finishRecording());
155    }
156
157    static sp<RenderNode> createNode(int left, int top, int right, int bottom,
158            std::function<void(RenderProperties& props, TestCanvas& canvas)> setup) {
159#if HWUI_NULL_GPU
160        // if RenderNodes are being sync'd/used, device info will be needed, since
161        // DeviceInfo::maxTextureSize() affects layer property
162        DeviceInfo::initialize();
163#endif
164
165        sp<RenderNode> node = new RenderNode();
166        RenderProperties& props = node->mutateStagingProperties();
167        props.setLeftTopRightBottom(left, top, right, bottom);
168        if (setup) {
169            TestCanvas canvas(props.getWidth(), props.getHeight());
170            setup(props, canvas);
171            node->setStagingDisplayList(canvas.finishRecording(), nullptr);
172        }
173        node->setPropertyFieldsDirty(0xFFFFFFFF);
174        return node;
175    }
176
177    static void recordNode(RenderNode& node,
178            std::function<void(TestCanvas&)> contentCallback) {
179       TestCanvas canvas(node.stagingProperties().getWidth(),
180               node.stagingProperties().getHeight());
181       contentCallback(canvas);
182       node.setStagingDisplayList(canvas.finishRecording(), nullptr);
183    }
184
185    /**
186     * Forces a sync of a tree of RenderNode, such that every descendant will have its staging
187     * properties and DisplayList moved to the render copies.
188     *
189     * Note: does not check dirtiness bits, so any non-staging DisplayLists will be discarded.
190     * For this reason, this should generally only be called once on a tree.
191     */
192    static void syncHierarchyPropertiesAndDisplayList(sp<RenderNode>& node) {
193        syncHierarchyPropertiesAndDisplayListImpl(node.get());
194    }
195
196    static sp<RenderNode>& getSyncedNode(sp<RenderNode>& node) {
197        syncHierarchyPropertiesAndDisplayList(node);
198        return node;
199    }
200
201    typedef std::function<void(renderthread::RenderThread& thread)> RtCallback;
202
203    class TestTask : public renderthread::RenderTask {
204    public:
205        TestTask(RtCallback rtCallback)
206                : rtCallback(rtCallback) {}
207        virtual ~TestTask() {}
208        virtual void run() override;
209        RtCallback rtCallback;
210    };
211
212    /**
213     * NOTE: requires surfaceflinger to run, otherwise this method will wait indefinitely.
214     */
215    static void runOnRenderThread(RtCallback rtCallback) {
216        TestTask task(rtCallback);
217        renderthread::RenderThread::getInstance().queueAndWait(&task);
218    }
219
220    static bool isRenderThreadRunning() {
221        return renderthread::RenderThread::hasInstance();
222    }
223
224    static SkColor interpolateColor(float fraction, SkColor start, SkColor end);
225
226    static void layoutTextUnscaled(const SkPaint& paint, const char* text,
227            std::vector<glyph_t>* outGlyphs, std::vector<float>* outPositions,
228            float* outTotalAdvance, Rect* outBounds);
229
230    static void drawUtf8ToCanvas(Canvas* canvas, const char* text,
231            const SkPaint& paint, float x, float y);
232
233    static void drawUtf8ToCanvas(Canvas* canvas, const char* text,
234            const SkPaint& paint, const SkPath& path);
235
236    static std::unique_ptr<uint16_t[]> asciiToUtf16(const char* str);
237
238private:
239    static void syncHierarchyPropertiesAndDisplayListImpl(RenderNode* node) {
240        node->syncProperties();
241        node->syncDisplayList(nullptr);
242        auto displayList = node->getDisplayList();
243        if (displayList) {
244            for (auto&& childOp : displayList->getChildren()) {
245                syncHierarchyPropertiesAndDisplayListImpl(childOp->renderNode);
246            }
247        }
248    }
249
250}; // class TestUtils
251
252} /* namespace uirenderer */
253} /* namespace android */
254
255#endif /* TEST_UTILS_H */
256