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
17#pragma once
18
19#include <DeviceInfo.h>
20#include <DisplayList.h>
21#include <Matrix.h>
22#include <Properties.h>
23#include <Rect.h>
24#include <RenderNode.h>
25#include <Snapshot.h>
26#include <hwui/Bitmap.h>
27#include <pipeline/skia/SkiaRecordingCanvas.h>
28#include <renderstate/RenderState.h>
29#include <renderthread/RenderThread.h>
30
31#include <RecordedOp.h>
32#include <RecordingCanvas.h>
33
34#include <memory>
35
36namespace android {
37namespace uirenderer {
38
39#define EXPECT_MATRIX_APPROX_EQ(a, b) EXPECT_TRUE(TestUtils::matricesAreApproxEqual(a, b))
40
41#define EXPECT_RECT_APPROX_EQ(a, b)                          \
42    EXPECT_TRUE(MathUtils::areEqual((a).left, (b).left) &&   \
43                MathUtils::areEqual((a).top, (b).top) &&     \
44                MathUtils::areEqual((a).right, (b).right) && \
45                MathUtils::areEqual((a).bottom, (b).bottom));
46
47#define EXPECT_CLIP_RECT(expRect, clipStatePtr)                                      \
48    EXPECT_NE(nullptr, (clipStatePtr)) << "Op is unclipped";                         \
49    if ((clipStatePtr)->mode == ClipMode::Rectangle) {                               \
50        EXPECT_EQ((expRect), reinterpret_cast<const ClipRect*>(clipStatePtr)->rect); \
51    } else {                                                                         \
52        ADD_FAILURE() << "ClipState not a rect";                                     \
53    }
54
55#define INNER_PIPELINE_TEST(test_case_name, test_name, pipeline, functionCall) \
56    TEST(test_case_name, test_name##_##pipeline) {                             \
57        RenderPipelineType oldType = Properties::getRenderPipelineType();      \
58        Properties::overrideRenderPipelineType(RenderPipelineType::pipeline);  \
59        functionCall;                                                          \
60        Properties::overrideRenderPipelineType(oldType);                       \
61    };
62
63/**
64 * Like gtests' TEST, but only runs with the OpenGL RenderPipelineType
65 */
66#define OPENGL_PIPELINE_TEST(test_case_name, test_name)                        \
67    class test_case_name##_##test_name##_HwuiTest {                            \
68    public:                                                                    \
69        static void doTheThing();                                              \
70    };                                                                         \
71    INNER_PIPELINE_TEST(test_case_name, test_name, OpenGL,                     \
72                        test_case_name##_##test_name##_HwuiTest::doTheThing()) \
73    void test_case_name##_##test_name##_HwuiTest::doTheThing()
74
75#define INNER_PIPELINE_RENDERTHREAD_TEST(test_case_name, test_name, pipeline) \
76    INNER_PIPELINE_TEST(test_case_name, test_name, pipeline,                  \
77                        TestUtils::runOnRenderThread(                         \
78                                test_case_name##_##test_name##_RenderThreadTest::doTheThing))
79
80/**
81 * Like gtest's TEST, but runs on the RenderThread, and 'renderThread' is passed, in top level scope
82 * (for e.g. accessing its RenderState)
83 */
84#define RENDERTHREAD_TEST(test_case_name, test_name)                                        \
85    class test_case_name##_##test_name##_RenderThreadTest {                                 \
86    public:                                                                                 \
87        static void doTheThing(renderthread::RenderThread& renderThread);                   \
88    };                                                                                      \
89    INNER_PIPELINE_RENDERTHREAD_TEST(test_case_name, test_name, OpenGL);                    \
90    INNER_PIPELINE_RENDERTHREAD_TEST(test_case_name, test_name, SkiaGL);                    \
91    /* Temporarily disabling Vulkan until we can figure out a way to stub out the driver */ \
92    /* INNER_PIPELINE_RENDERTHREAD_TEST(test_case_name, test_name, SkiaVulkan); */          \
93    void test_case_name##_##test_name##_RenderThreadTest::doTheThing(                       \
94            renderthread::RenderThread& renderThread)
95
96/**
97 * Like RENDERTHREAD_TEST, but only runs with the OpenGL RenderPipelineType
98 */
99#define RENDERTHREAD_OPENGL_PIPELINE_TEST(test_case_name, test_name)      \
100    class test_case_name##_##test_name##_RenderThreadTest {               \
101    public:                                                               \
102        static void doTheThing(renderthread::RenderThread& renderThread); \
103    };                                                                    \
104    INNER_PIPELINE_RENDERTHREAD_TEST(test_case_name, test_name, OpenGL);  \
105    void test_case_name##_##test_name##_RenderThreadTest::doTheThing(     \
106            renderthread::RenderThread& renderThread)
107
108/**
109 * Like RENDERTHREAD_TEST, but only runs with the Skia RenderPipelineTypes
110 */
111#define RENDERTHREAD_SKIA_PIPELINE_TEST(test_case_name, test_name)                          \
112    class test_case_name##_##test_name##_RenderThreadTest {                                 \
113    public:                                                                                 \
114        static void doTheThing(renderthread::RenderThread& renderThread);                   \
115    };                                                                                      \
116    INNER_PIPELINE_RENDERTHREAD_TEST(test_case_name, test_name, SkiaGL);                    \
117    /* Temporarily disabling Vulkan until we can figure out a way to stub out the driver */ \
118    /* INNER_PIPELINE_RENDERTHREAD_TEST(test_case_name, test_name, SkiaVulkan); */          \
119    void test_case_name##_##test_name##_RenderThreadTest::doTheThing(                       \
120            renderthread::RenderThread& renderThread)
121
122/**
123 * Sets a property value temporarily, generally for the duration of a test, restoring the previous
124 * value when going out of scope.
125 *
126 * Can be used e.g. to test behavior only active while Properties::debugOverdraw is enabled.
127 */
128template <typename T>
129class ScopedProperty {
130public:
131    ScopedProperty(T& property, T newValue) : mPropertyPtr(&property), mOldValue(property) {
132        property = newValue;
133    }
134    ~ScopedProperty() { *mPropertyPtr = mOldValue; }
135
136private:
137    T* mPropertyPtr;
138    T mOldValue;
139};
140
141class TestUtils {
142public:
143    class SignalingDtor {
144    public:
145        SignalingDtor() : mSignal(nullptr) {}
146        explicit SignalingDtor(int* signal) : mSignal(signal) {}
147        void setSignal(int* signal) { mSignal = signal; }
148        ~SignalingDtor() {
149            if (mSignal) {
150                (*mSignal)++;
151            }
152        }
153
154    private:
155        int* mSignal;
156    };
157
158    class MockTreeObserver : public TreeObserver {
159    public:
160        virtual void onMaybeRemovedFromTree(RenderNode* node) {}
161    };
162
163    static bool matricesAreApproxEqual(const Matrix4& a, const Matrix4& b) {
164        for (int i = 0; i < 16; i++) {
165            if (!MathUtils::areEqual(a[i], b[i])) {
166                return false;
167            }
168        }
169        return true;
170    }
171
172    static std::unique_ptr<Snapshot> makeSnapshot(const Matrix4& transform, const Rect& clip) {
173        std::unique_ptr<Snapshot> snapshot(new Snapshot());
174        // store clip first, so it isn't transformed
175        snapshot->setClip(clip.left, clip.top, clip.right, clip.bottom);
176        *(snapshot->transform) = transform;
177        return snapshot;
178    }
179
180    static sk_sp<Bitmap> createBitmap(int width, int height,
181                                      SkColorType colorType = kN32_SkColorType) {
182        SkImageInfo info = SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType);
183        return Bitmap::allocateHeapBitmap(info);
184    }
185
186    static sk_sp<Bitmap> createBitmap(int width, int height, SkBitmap* outBitmap) {
187        SkImageInfo info = SkImageInfo::Make(width, height, kN32_SkColorType, kPremul_SkAlphaType);
188        outBitmap->setInfo(info);
189        return Bitmap::allocateHeapBitmap(outBitmap);
190    }
191
192    static sp<DeferredLayerUpdater> createTextureLayerUpdater(
193            renderthread::RenderThread& renderThread);
194
195    static sp<DeferredLayerUpdater> createTextureLayerUpdater(
196            renderthread::RenderThread& renderThread, uint32_t width, uint32_t height,
197            const SkMatrix& transform);
198
199    template <class CanvasType>
200    static std::unique_ptr<DisplayList> createDisplayList(
201            int width, int height, std::function<void(CanvasType& canvas)> canvasCallback) {
202        CanvasType canvas(width, height);
203        canvasCallback(canvas);
204        return std::unique_ptr<DisplayList>(canvas.finishRecording());
205    }
206
207    static sp<RenderNode> createNode(
208            int left, int top, int right, int bottom,
209            std::function<void(RenderProperties& props, Canvas& canvas)> setup) {
210#if HWUI_NULL_GPU
211        // if RenderNodes are being sync'd/used, device info will be needed, since
212        // DeviceInfo::maxTextureSize() affects layer property
213        DeviceInfo::initialize();
214#endif
215
216        sp<RenderNode> node = new RenderNode();
217        RenderProperties& props = node->mutateStagingProperties();
218        props.setLeftTopRightBottom(left, top, right, bottom);
219        if (setup) {
220            std::unique_ptr<Canvas> canvas(
221                    Canvas::create_recording_canvas(props.getWidth(), props.getHeight()));
222            setup(props, *canvas.get());
223            node->setStagingDisplayList(canvas->finishRecording());
224        }
225        node->setPropertyFieldsDirty(0xFFFFFFFF);
226        return node;
227    }
228
229    template <class RecordingCanvasType>
230    static sp<RenderNode> createNode(
231            int left, int top, int right, int bottom,
232            std::function<void(RenderProperties& props, RecordingCanvasType& canvas)> setup) {
233#if HWUI_NULL_GPU
234        // if RenderNodes are being sync'd/used, device info will be needed, since
235        // DeviceInfo::maxTextureSize() affects layer property
236        DeviceInfo::initialize();
237#endif
238
239        sp<RenderNode> node = new RenderNode();
240        RenderProperties& props = node->mutateStagingProperties();
241        props.setLeftTopRightBottom(left, top, right, bottom);
242        if (setup) {
243            RecordingCanvasType canvas(props.getWidth(), props.getHeight());
244            setup(props, canvas);
245            node->setStagingDisplayList(canvas.finishRecording());
246        }
247        node->setPropertyFieldsDirty(0xFFFFFFFF);
248        return node;
249    }
250
251    static void recordNode(RenderNode& node, std::function<void(Canvas&)> contentCallback) {
252        std::unique_ptr<Canvas> canvas(Canvas::create_recording_canvas(
253                node.stagingProperties().getWidth(), node.stagingProperties().getHeight(),
254                &node));
255        contentCallback(*canvas.get());
256        node.setStagingDisplayList(canvas->finishRecording());
257    }
258
259    static sp<RenderNode> createSkiaNode(
260            int left, int top, int right, int bottom,
261            std::function<void(RenderProperties& props, skiapipeline::SkiaRecordingCanvas& canvas)>
262                    setup,
263            const char* name = nullptr, skiapipeline::SkiaDisplayList* displayList = nullptr) {
264#if HWUI_NULL_GPU
265        // if RenderNodes are being sync'd/used, device info will be needed, since
266        // DeviceInfo::maxTextureSize() affects layer property
267        DeviceInfo::initialize();
268#endif
269        sp<RenderNode> node = new RenderNode();
270        if (name) {
271            node->setName(name);
272        }
273        RenderProperties& props = node->mutateStagingProperties();
274        props.setLeftTopRightBottom(left, top, right, bottom);
275        if (displayList) {
276            node->setStagingDisplayList(displayList);
277        }
278        if (setup) {
279            std::unique_ptr<skiapipeline::SkiaRecordingCanvas> canvas(
280                    new skiapipeline::SkiaRecordingCanvas(nullptr, props.getWidth(),
281                                                          props.getHeight()));
282            setup(props, *canvas.get());
283            node->setStagingDisplayList(canvas->finishRecording());
284        }
285        node->setPropertyFieldsDirty(0xFFFFFFFF);
286        TestUtils::syncHierarchyPropertiesAndDisplayList(node);
287        return node;
288    }
289
290    /**
291     * Forces a sync of a tree of RenderNode, such that every descendant will have its staging
292     * properties and DisplayList moved to the render copies.
293     *
294     * Note: does not check dirtiness bits, so any non-staging DisplayLists will be discarded.
295     * For this reason, this should generally only be called once on a tree.
296     */
297    static void syncHierarchyPropertiesAndDisplayList(sp<RenderNode>& node) {
298        syncHierarchyPropertiesAndDisplayListImpl(node.get());
299    }
300
301    static sp<RenderNode>& getSyncedNode(sp<RenderNode>& node) {
302        syncHierarchyPropertiesAndDisplayList(node);
303        return node;
304    }
305
306    typedef std::function<void(renderthread::RenderThread& thread)> RtCallback;
307
308    class TestTask : public renderthread::RenderTask {
309    public:
310        explicit TestTask(RtCallback rtCallback) : rtCallback(rtCallback) {}
311        virtual ~TestTask() {}
312        virtual void run() override;
313        RtCallback rtCallback;
314    };
315
316    /**
317     * NOTE: requires surfaceflinger to run, otherwise this method will wait indefinitely.
318     */
319    static void runOnRenderThread(RtCallback rtCallback) {
320        TestTask task(rtCallback);
321        renderthread::RenderThread::getInstance().queue().runSync([&]() { task.run(); });
322    }
323
324    static bool isRenderThreadRunning() { return renderthread::RenderThread::hasInstance(); }
325
326    static SkColor interpolateColor(float fraction, SkColor start, SkColor end);
327
328    static void layoutTextUnscaled(const SkPaint& paint, const char* text,
329                                   std::vector<glyph_t>* outGlyphs,
330                                   std::vector<float>* outPositions, float* outTotalAdvance,
331                                   Rect* outBounds);
332
333    static void drawUtf8ToCanvas(Canvas* canvas, const char* text, const SkPaint& paint, float x,
334                                 float y);
335
336    static void drawUtf8ToCanvas(Canvas* canvas, const char* text, const SkPaint& paint,
337                                 const SkPath& path);
338
339    static std::unique_ptr<uint16_t[]> asciiToUtf16(const char* str);
340
341    class MockFunctor : public Functor {
342    public:
343        virtual status_t operator()(int what, void* data) {
344            mLastMode = what;
345            return DrawGlInfo::kStatusDone;
346        }
347        int getLastMode() const { return mLastMode; }
348
349    private:
350        int mLastMode = -1;
351    };
352
353    static SkColor getColor(const sk_sp<SkSurface>& surface, int x, int y);
354
355    static SkRect getClipBounds(const SkCanvas* canvas);
356    static SkRect getLocalClipBounds(const SkCanvas* canvas);
357
358private:
359    static void syncHierarchyPropertiesAndDisplayListImpl(RenderNode* node) {
360        MarkAndSweepRemoved observer(nullptr);
361        node->syncProperties();
362        if (node->mNeedsDisplayListSync) {
363            node->mNeedsDisplayListSync = false;
364            node->syncDisplayList(observer, nullptr);
365        }
366        auto displayList = node->getDisplayList();
367        if (displayList) {
368            if (displayList->isSkiaDL()) {
369                for (auto&& childDr : static_cast<skiapipeline::SkiaDisplayList*>(
370                                              const_cast<DisplayList*>(displayList))
371                                              ->mChildNodes) {
372                    syncHierarchyPropertiesAndDisplayListImpl(childDr.getRenderNode());
373                }
374            } else {
375                for (auto&& childOp : displayList->getChildren()) {
376                    syncHierarchyPropertiesAndDisplayListImpl(childOp->renderNode);
377                }
378            }
379        }
380    }
381
382};  // class TestUtils
383
384} /* namespace uirenderer */
385} /* namespace android */
386