1 // Copyright 2021 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 #include <gmock/gmock.h>
15 #include <gtest/gtest.h>
16
17 #include "VirtioGpuTimelines.h"
18
19 #include <memory>
20
21 class VirtioGpuTimelinesTest : public ::testing::Test {
22 protected:
23 std::unique_ptr<VirtioGpuTimelines> mVirtioGpuTimelines;
SetUp()24 void SetUp() override {
25 mVirtioGpuTimelines = std::make_unique<VirtioGpuTimelines>();
26 }
27 };
28
TEST_F(VirtioGpuTimelinesTest,Init)29 TEST_F(VirtioGpuTimelinesTest, Init) {}
30
TEST_F(VirtioGpuTimelinesTest,TasksShouldHaveDifferentIds)31 TEST_F(VirtioGpuTimelinesTest, TasksShouldHaveDifferentIds) {
32 auto taskId1 = mVirtioGpuTimelines->enqueueTask(0);
33 auto taskId2 = mVirtioGpuTimelines->enqueueTask(0);
34 ASSERT_NE(taskId1, taskId2);
35 }
36
TEST_F(VirtioGpuTimelinesTest,MultipleTasksAndFences)37 TEST_F(VirtioGpuTimelinesTest, MultipleTasksAndFences) {
38 using namespace testing;
39 MockFunction<void(int)> check;
40 MockFunction<void()> fence1Callback;
41 MockFunction<void()> fence2Callback;
42 MockFunction<void()> fence3Callback;
43 VirtioGpuTimelines::CtxId ctxId = 0;
44 VirtioGpuTimelines::FenceId fenceId = 0;
45 {
46 InSequence s;
47
48 EXPECT_CALL(check, Call(1));
49 EXPECT_CALL(fence1Callback, Call());
50 EXPECT_CALL(check, Call(2));
51 EXPECT_CALL(check, Call(3));
52 EXPECT_CALL(fence2Callback, Call());
53 EXPECT_CALL(check, Call(4));
54 EXPECT_CALL(fence3Callback, Call());
55 }
56
57 auto task1Id = mVirtioGpuTimelines->enqueueTask(ctxId);
58 mVirtioGpuTimelines->enqueueFence(ctxId, fenceId++,
59 fence1Callback.AsStdFunction());
60 auto task2Id = mVirtioGpuTimelines->enqueueTask(ctxId);
61 mVirtioGpuTimelines->enqueueFence(ctxId, fenceId++,
62 fence2Callback.AsStdFunction());
63 check.Call(1);
64 mVirtioGpuTimelines->notifyTaskCompletion(task1Id);
65 check.Call(2);
66 auto task3Id = mVirtioGpuTimelines->enqueueTask(ctxId);
67 mVirtioGpuTimelines->enqueueFence(ctxId, fenceId++,
68 fence3Callback.AsStdFunction());
69 check.Call(3);
70 mVirtioGpuTimelines->notifyTaskCompletion(task2Id);
71 check.Call(4);
72 mVirtioGpuTimelines->notifyTaskCompletion(task3Id);
73 }
74
TEST_F(VirtioGpuTimelinesTest,FencesWithoutPendingTasks)75 TEST_F(VirtioGpuTimelinesTest, FencesWithoutPendingTasks) {
76 using namespace testing;
77 MockFunction<void()> fenceCallback1;
78 MockFunction<void()> fenceCallback2;
79 VirtioGpuTimelines::CtxId ctxId = 0;
80 VirtioGpuTimelines::FenceId fenceId = 0;
81 {
82 InSequence s;
83 EXPECT_CALL(fenceCallback1, Call());
84 EXPECT_CALL(fenceCallback2, Call());
85 }
86
87 mVirtioGpuTimelines->enqueueFence(ctxId, fenceId++,
88 fenceCallback1.AsStdFunction());
89 mVirtioGpuTimelines->enqueueFence(ctxId, fenceId++,
90 fenceCallback2.AsStdFunction());
91 }
92
TEST_F(VirtioGpuTimelinesTest,FencesSharingSamePendingTasks)93 TEST_F(VirtioGpuTimelinesTest, FencesSharingSamePendingTasks) {
94 using namespace testing;
95 MockFunction<void()> fenceCallback1;
96 MockFunction<void()> fenceCallback2;
97 MockFunction<void(int)> check;
98 VirtioGpuTimelines::CtxId ctxId = 0;
99 VirtioGpuTimelines::FenceId fenceId = 0;
100 {
101 InSequence s;
102 EXPECT_CALL(check, Call(1));
103 EXPECT_CALL(fenceCallback1, Call());
104 EXPECT_CALL(fenceCallback2, Call());
105 }
106
107 auto taskId = mVirtioGpuTimelines->enqueueTask(ctxId);
108 mVirtioGpuTimelines->enqueueFence(ctxId, fenceId++,
109 fenceCallback1.AsStdFunction());
110 mVirtioGpuTimelines->enqueueFence(ctxId, fenceId++,
111 fenceCallback2.AsStdFunction());
112 check.Call(1);
113 mVirtioGpuTimelines->notifyTaskCompletion(taskId);
114 }
115
TEST_F(VirtioGpuTimelinesTest,TasksAndFencesOnMultipleContexts)116 TEST_F(VirtioGpuTimelinesTest, TasksAndFencesOnMultipleContexts) {
117 using namespace testing;
118 MockFunction<void()> fence1Callback;
119 MockFunction<void()> fence2Callback;
120 MockFunction<void()> fence3Callback;
121 MockFunction<void(int)> check;
122 {
123 InSequence s;
124
125 EXPECT_CALL(check, Call(1));
126 EXPECT_CALL(fence1Callback, Call());
127 EXPECT_CALL(check, Call(2));
128 EXPECT_CALL(fence2Callback, Call());
129 EXPECT_CALL(check, Call(3));
130 EXPECT_CALL(fence3Callback, Call());
131 }
132 auto taskId2 = mVirtioGpuTimelines->enqueueTask(2);
133 auto taskId3 = mVirtioGpuTimelines->enqueueTask(3);
134 check.Call(1);
135 mVirtioGpuTimelines->enqueueFence(1, 1, fence1Callback.AsStdFunction());
136 check.Call(2);
137 mVirtioGpuTimelines->enqueueFence(2, 2, fence2Callback.AsStdFunction());
138 mVirtioGpuTimelines->enqueueFence(3, 3, fence3Callback.AsStdFunction());
139 mVirtioGpuTimelines->notifyTaskCompletion(taskId2);
140 check.Call(3);
141 mVirtioGpuTimelines->notifyTaskCompletion(taskId3);
142 }
143