1 /*
2  * Copyright (C) 2021 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 package com.android.systemui.screenshot;
18 
19 import static com.google.common.util.concurrent.Futures.getUnchecked;
20 
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertNotNull;
23 import static org.junit.Assert.assertNull;
24 import static org.junit.Assert.assertTrue;
25 
26 import android.testing.AndroidTestingRunner;
27 
28 import androidx.test.filters.SmallTest;
29 
30 import com.android.systemui.SysuiTestCase;
31 
32 import org.junit.Test;
33 import org.junit.runner.RunWith;
34 
35 /**
36  * Tests for {@link FakeSession}, a a test double for a ScrollCaptureClient.Session.
37  * <p>
38  * These tests verify a single tile request behaves similarly to a live scroll capture
39  * client/connection.
40  */
41 @SmallTest
42 @RunWith(AndroidTestingRunner.class)
43 public class FakeSessionTest extends SysuiTestCase {
44     @Test
testNonEmptyResult_hasImage()45     public void testNonEmptyResult_hasImage() {
46         FakeSession session = new FakeSession(
47                 /* pageHeight */ 100,
48                 /* maxPages */ 1.0f,
49                 /* tileHeight */ 10,
50                 /* visiblePageTop */ 0,
51                 /* visiblePageBottom */ 100,
52                 /* availableTop */ 0,
53                 /* availableBottom */ 100,
54                 /* max Tiles */ 30);
55         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(0));
56         assertNotNull("result.image", result.image);
57         assertNotNull("result.image.getHardwareBuffer()", result.image.getHardwareBuffer());
58     }
59 
60     @Test
testEmptyResult_hasNullImage()61     public void testEmptyResult_hasNullImage() {
62         FakeSession session = new FakeSession(
63                 /* pageHeight */ 100,
64                 /* maxPages */ 1.0f,
65                 /* tileHeight */ 10,
66                 /* visiblePageTop */ 0,
67                 /* visiblePageBottom */ 100,
68                 /* availableTop */ 0,
69                 /* availableBottom */ 100,
70                 /* max Tiles */ 30);
71         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(-100));
72         assertNull("result.image", result.image);
73     }
74 
75     @Test
testCaptureAtZero()76     public void testCaptureAtZero() {
77         FakeSession session = new FakeSession(
78                 /* pageHeight */ 100,
79                 /* maxPages */ 2.5f,
80                 /* tileHeight */ 10,
81                 /* visiblePageTop */ 0,
82                 /* visiblePageBottom */ 100,
83                 /* availableTop */ -250,
84                 /* availableBottom */ 250,
85                 /* max Tiles */ 30);
86 
87         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(0));
88         assertEquals("requested top", 0, result.requested.top);
89         assertEquals("requested bottom", 10, result.requested.bottom);
90         assertEquals("captured top", 0, result.captured.top);
91         assertEquals("captured bottom", 10, result.captured.bottom);
92         assertEquals("scroll delta", 0, session.getScrollDelta());
93     }
94 
95     @Test
testCaptureAtPageBottom()96     public void testCaptureAtPageBottom() {
97         FakeSession session = new FakeSession(
98                 /* pageHeight */ 100,
99                 /* maxPages */ 2.5f,
100                 /* tileHeight */ 10,
101                 /* visiblePageTop */ 0,
102                 /* visiblePageBottom */ 100,
103                 /* availableTop */ -250,
104                 /* availableBottom */ 250,
105                 /* max Tiles */ 30);
106 
107         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(90));
108         assertEquals("requested top", 90, result.requested.top);
109         assertEquals("requested bottom", 100, result.requested.bottom);
110         assertEquals("captured top", 90, result.captured.top);
111         assertEquals("captured bottom", 100, result.captured.bottom);
112         assertEquals("scroll delta", 0, session.getScrollDelta());
113     }
114 
115     @Test
testCaptureFromPreviousPage()116     public void testCaptureFromPreviousPage() {
117         FakeSession session = new FakeSession(
118                 /* pageHeight */ 100,
119                 /* maxPages */ 2.5f,
120                 /* tileHeight */ 10,
121                 /* visiblePageTop */ 0,
122                 /* visiblePageBottom */ 100,
123                 /* availableTop */ -250,
124                 /* availableBottom */ 250,
125                 /* max Tiles */ 30);
126 
127         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(-100));
128         assertEquals("requested top", -100, result.requested.top);
129         assertEquals("requested bottom", -90, result.requested.bottom);
130         assertEquals("captured top", -100, result.captured.top);
131         assertEquals("captured bottom", -90, result.captured.bottom);
132         assertEquals("scroll delta", -100, session.getScrollDelta());
133     }
134 
135     @Test
testCaptureFromNextPage()136     public void testCaptureFromNextPage() {
137         FakeSession session = new FakeSession(
138                 /* pageHeight */ 100,
139                 /* maxPages */ 2.5f,
140                 /* tileHeight */ 10,
141                 /* visiblePageTop */ 0,
142                 /* visiblePageBottom */ 100,
143                 /* availableTop */ -250,
144                 /* availableBottom */ 250,
145                 /* max Tiles */ 30);
146 
147         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(150));
148         assertEquals("requested top", 150, result.requested.top);
149         assertEquals("requested bottom", 160, result.requested.bottom);
150         assertEquals("captured top", 150, result.captured.top);
151         assertEquals("captured bottom", 160, result.captured.bottom);
152         assertEquals("scroll delta", 60, session.getScrollDelta());
153     }
154 
155     @Test
testCaptureTopPartiallyUnavailable()156     public void testCaptureTopPartiallyUnavailable() {
157         FakeSession session = new FakeSession(
158                 /* pageHeight */ 100,
159                 /* maxPages */ 3f,
160                 /* tileHeight */ 50,
161                 /* visiblePageTop */ 0,
162                 /* visiblePageBottom */ 100,
163                 /* availableTop */ -100,
164                 /* availableBottom */ 100,
165                 /* max Tiles */ 30);
166 
167         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(-125));
168         assertEquals("requested top", -125, result.requested.top);
169         assertEquals("requested bottom", -75, result.requested.bottom);
170         assertEquals("captured top", -100, result.captured.top);
171         assertEquals("captured bottom", -75, result.captured.bottom);
172         assertEquals("scroll delta", -100, session.getScrollDelta());
173     }
174 
175     @Test
testCaptureBottomPartiallyUnavailable()176     public void testCaptureBottomPartiallyUnavailable() {
177         FakeSession session = new FakeSession(
178                 /* pageHeight */ 100,
179                 /* maxPages */ 3f,
180                 /* tileHeight */ 50,
181                 /* visiblePageTop */ 0,
182                 /* visiblePageBottom */ 100,
183                 /* availableTop */ -100,
184                 /* availableBottom */ 100,
185                 /* max Tiles */ 30);
186 
187         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(75));
188         assertEquals("requested top", 75, result.requested.top);
189         assertEquals("requested bottom", 125, result.requested.bottom);
190         assertEquals("captured top", 75, result.captured.top);
191         assertEquals("captured bottom", 100, result.captured.bottom);
192         assertEquals("scroll delta", 0, session.getScrollDelta());
193     }
194 
195     /**
196      * Set visiblePageTop > 0  to cause the returned request's top edge to be cropped.
197      */
198     @Test
testCaptureTopPartiallyInvisible()199     public void testCaptureTopPartiallyInvisible() {
200         FakeSession session = new FakeSession(
201                 /* pageHeight */ 100,
202                 /* maxPages */ 3f,
203                 /* tileHeight */ 50,
204                 /* visiblePageTop */ 25,  // <<--
205                 /* visiblePageBottom */ 100,
206                 /* availableTop */ -150,
207                 /* availableBottom */ 150,
208                 /* max Tiles */ 30);
209 
210         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(-150));
211         assertEquals("requested top", -150, result.requested.top);
212         assertEquals("requested bottom", -100, result.requested.bottom);
213         assertEquals("captured top", -125, result.captured.top);
214         assertEquals("captured bottom", -100, result.captured.bottom);
215         assertEquals("scroll delta", -150, session.getScrollDelta());
216     }
217 
218     /**
219      * Set visiblePageBottom < pageHeight to cause the returned request's bottom edge to be cropped.
220      */
221     @Test
testCaptureBottomPartiallyInvisible()222     public void testCaptureBottomPartiallyInvisible() {
223         FakeSession session = new FakeSession(
224                 /* pageHeight */ 100,
225                 /* maxPages */ 3f,
226                 /* tileHeight */ 50,
227                 /* visiblePageTop */ 0,
228                 /* visiblePageBottom */ 75,
229                 /* availableTop */ -150,
230                 /* availableBottom */ 150,
231                 /* max Tiles */ 30);
232 
233         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(50));
234         assertEquals("requested top", 50, result.requested.top);
235         assertEquals("requested bottom", 100, result.requested.bottom);
236         assertEquals("captured top", 50, result.captured.top);
237         assertEquals("captured bottom", 75, result.captured.bottom);
238         assertEquals("scroll delta", 0, session.getScrollDelta());
239     }
240 
241     @Test
testEmptyResult_aboveAvailableTop()242     public void testEmptyResult_aboveAvailableTop() {
243         FakeSession session = new FakeSession(
244                 /* pageHeight */ 100,
245                 /* maxPages */ 3.0f,
246                 /* tileHeight */ 50,
247                 /* visiblePageTop */ 0,
248                 /* visiblePageBottom */ 100,
249                 /* availableTop */ -100,
250                 /* availableBottom */ 200,
251                 /* max Tiles */ 30);
252         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(-150));
253         assertTrue("captured rect is empty", result.captured.isEmpty());
254     }
255 
256     @Test
testEmptyResult_belowAvailableBottom()257     public void testEmptyResult_belowAvailableBottom() {
258         FakeSession session = new FakeSession(
259                 /* pageHeight */ 100,
260                 /* maxPages */ 3.0f,
261                 /* tileHeight */ 50,
262                 /* visiblePageTop */ 0,
263                 /* visiblePageBottom */ 100,
264                 /* availableTop */ -100,
265                 /* availableBottom */ 200,
266                 /* max Tiles */ 30);
267         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(200));
268         assertTrue("captured rect is empty", result.captured.isEmpty());
269     }
270 
271     @Test
testEmptyResult_notVisible()272     public void testEmptyResult_notVisible() {
273         FakeSession session = new FakeSession(
274                 /* pageHeight */ 100,
275                 /* maxPages */ 3f,
276                 /* tileHeight */ 50,
277                 /* visiblePageTop */ 60,  // <<---
278                 /* visiblePageBottom */ 0,
279                 /* availableTop */ -150,
280                 /* availableBottom */ 150,
281                 /* max Tiles */ 30);
282 
283         ScrollCaptureClient.CaptureResult result = getUnchecked(session.requestTile(0));
284         assertEquals("requested top", 0, result.requested.top);
285         assertEquals("requested bottom", 50, result.requested.bottom);
286         assertEquals("captured top", 0, result.captured.top);
287         assertEquals("captured bottom", 0, result.captured.bottom);
288         assertEquals("scroll delta", 0, session.getScrollDelta());
289     }
290 
291 }
292