• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2008 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 android.graphics.cts;
18 
19 import android.graphics.Path;
20 import android.graphics.Rect;
21 import android.graphics.Region;
22 import android.os.Parcel;
23 import android.test.AndroidTestCase;
24 
25 public class RegionTest extends AndroidTestCase {
26 
27     // DIFFERENCE
28     private final static int[][] DIFFERENCE_WITH1 = {{0, 0}, {4, 4},
29         {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19}};
30     private final static int[][] DIFFERENCE_WITHOUT1 = {{5, 5}, {9, 9},
31         {9, 5}, {5, 9}};
32 
33     private final static int[][] DIFFERENCE_WITH2 = {{0, 0}, {19, 0}, {9, 9},
34         {19, 9}, {0, 19}, {9, 19}};
35     private final static int[][] DIFFERENCE_WITHOUT2 = {{10, 10}, {19, 10},
36         {10, 19}, {19, 19}, {29, 10}, {29, 29}, {10, 29}};
37 
38     private final static int[][] DIFFERENCE_WITH3 = {{0, 0}, {19, 0}, {0, 19},
39         {19, 19}};
40     private final static int[][] DIFFERENCE_WITHOUT3 = {{40, 40}, {40, 59},
41         {59, 40}, {59, 59}};
42 
43     // INTERSECT
44     private final static int[][] INTERSECT_WITH1 = {{5, 5}, {9, 9},
45         {9, 5}, {5, 9}};
46     private final static int[][] INTERSECT_WITHOUT1 = {{0, 0}, {2, 2}, {4, 4},
47         {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19}};
48 
49     private final static int[][] INTERSECT_WITH2 = {{10, 10}, {19, 10},
50         {10, 19}, {19, 19}};
51     private final static int[][] INTERSECT_WITHOUT2 = {{0, 0}, {19, 0}, {9, 9},
52         {19, 9}, {0, 19}, {9, 19}, {29, 10}, {29, 29}, {10, 29}};
53 
54     // UNION
55     private final static int[][] UNION_WITH1 = {{0, 0}, {2, 2}, {4, 4}, {6, 6},
56         {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19},
57         {5, 5}, {9, 9}, {9, 5}, {5, 9}};
58     private final static int[][] UNION_WITHOUT1 = {{0, 20}, {20, 20}, {20, 0}};
59 
60     private final static int[][] UNION_WITH2 = {
61         {0, 0}, {2, 2}, {19, 0}, {9, 9}, {19, 9}, {0, 19}, {9, 19}, {21, 21},
62         {10, 10}, {19, 10}, {10, 19}, {19, 19}, {29, 10}, {29, 29}, {10, 29}};
63     private final static int[][] UNION_WITHOUT2 = {
64         {0, 29}, {0, 20}, {9, 29}, {9, 20},
65         {29, 0}, {20, 0}, {29, 9}, {20, 9}};
66 
67     private final static int[][] UNION_WITH3 = {
68         {0, 0}, {2, 2}, {19, 0}, {0, 19}, {19, 19},
69         {40, 40}, {41, 41}, {40, 59}, {59, 40}, {59, 59}};
70     private final static int[][] UNION_WITHOUT3 = {{20, 20}, {39, 39}};
71 
72     // XOR
73     private final static int[][] XOR_WITH1 = {{0, 0}, {2, 2}, {4, 4},
74         {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19}};
75     private final static int[][] XOR_WITHOUT1 = {{5, 5}, {6, 6}, {9, 9},
76         {9, 5}, {5, 9}};
77 
78     private final static int[][] XOR_WITH2 = {
79         {0, 0}, {2, 2}, {19, 0}, {9, 9}, {19, 9}, {0, 19}, {9, 19}, {21, 21},
80         {29, 10}, {10, 29}, {20, 10}, {10, 20}, {20, 20}, {29, 29}};
81     private final static int[][] XOR_WITHOUT2 = {{10, 10}, {11, 11}, {19, 10},
82         {10, 19}, {19, 19}};
83 
84     private final static int[][] XOR_WITH3 = {
85         {0, 0}, {2, 2}, {19, 0}, {0, 19}, {19, 19},
86         {40, 40}, {41, 41}, {40, 59}, {59, 40}, {59, 59}};
87     private final static int[][] XOR_WITHOUT3 = {{20, 20}, {39, 39}};
88 
89     // REVERSE_DIFFERENCE
90     private final static int[][] REVERSE_DIFFERENCE_WITH2 = {{29, 10}, {10, 29},
91         {20, 10}, {10, 20}, {20, 20}, {29, 29}, {21, 21}};
92     private final static int[][] REVERSE_DIFFERENCE_WITHOUT2 = {{0, 0}, {19, 0},
93         {0, 19}, {19, 19}, {2, 2}, {11, 11}};
94 
95     private final static int[][] REVERSE_DIFFERENCE_WITH3 = {{40, 40}, {40, 59},
96         {59, 40}, {59, 59}, {41, 41}};
97     private final static int[][] REVERSE_DIFFERENCE_WITHOUT3 = {{0, 0}, {19, 0},
98         {0, 19}, {19, 19}, {20, 20}, {39, 39}, {2, 2}};
99 
100     private Region mRegion;
101 
assertPointsInsideRegion(int[][] area)102     private void assertPointsInsideRegion(int[][] area) {
103         for (int i = 0; i < area.length; i ++) {
104             assertTrue(mRegion.contains(area[i][0], area[i][1]));
105         }
106     }
107 
assertPointsOutsideRegion(int[][] area)108     private void assertPointsOutsideRegion(int[][] area) {
109         for (int i = 0; i < area.length; i ++) {
110             assertFalse(mRegion.contains(area[i][0], area[i][1]));
111         }
112     }
113 
testConstructor()114     public void testConstructor() {
115         // Test Region()
116         new Region();
117 
118         // Test Region(Region)
119         Region oriRegion = new Region();
120         new Region(oriRegion);
121 
122         // Test Region(Rect)
123         Rect rect = new Rect();
124         new Region(rect);
125 
126         // Test Region(int, int, int, int)
127         new Region(0, 0, 100, 100);
128     }
129 
testSet1()130     public void testSet1() {
131 
132         mRegion = new Region();
133         Rect rect = new Rect(1, 2, 3, 4);
134         Region oriRegion = new Region(rect);
135         assertTrue(mRegion.set(oriRegion));
136         assertEquals(1, mRegion.getBounds().left);
137         assertEquals(2, mRegion.getBounds().top);
138         assertEquals(3, mRegion.getBounds().right);
139         assertEquals(4, mRegion.getBounds().bottom);
140     }
141 
testSet2()142     public void testSet2() {
143 
144         mRegion = new Region();
145         Rect rect = new Rect(1, 2, 3, 4);
146         assertTrue(mRegion.set(rect));
147         assertEquals(1, mRegion.getBounds().left);
148         assertEquals(2, mRegion.getBounds().top);
149         assertEquals(3, mRegion.getBounds().right);
150         assertEquals(4, mRegion.getBounds().bottom);
151     }
152 
testSet3()153     public void testSet3() {
154 
155         mRegion = new Region();
156         assertTrue(mRegion.set(1, 2, 3, 4));
157         assertEquals(1, mRegion.getBounds().left);
158         assertEquals(2, mRegion.getBounds().top);
159         assertEquals(3, mRegion.getBounds().right);
160         assertEquals(4, mRegion.getBounds().bottom);
161     }
162 
testIsRect()163     public void testIsRect() {
164 
165         mRegion = new Region();
166         assertFalse(mRegion.isRect());
167         mRegion = new Region(1, 2, 3, 4);
168         assertTrue(mRegion.isRect());
169     }
170 
testIsComplex()171     public void testIsComplex() {
172 
173         // Region is null
174         mRegion = new Region();
175         assertFalse(mRegion.isComplex());
176 
177         // Only one rectangle
178         mRegion = new Region();
179         mRegion.set(1, 2, 3, 4);
180         assertFalse(mRegion.isComplex());
181 
182         // More than one rectangle
183         mRegion = new Region();
184         mRegion.set(1, 1, 2, 2);
185         mRegion.union(new Rect(3, 3, 5, 5));
186         assertTrue(mRegion.isComplex());
187     }
188 
testQuickContains1()189     public void testQuickContains1() {
190 
191         mRegion = new Region();
192         Rect rect = new Rect(1, 2, 3, 4);
193         // This region not contains expected rectangle.
194         assertFalse(mRegion.quickContains(rect));
195         mRegion.set(rect);
196         // This region contains only one rectangle and it is the expected one.
197         assertTrue(mRegion.quickContains(rect));
198         mRegion.set(5, 6, 7, 8);
199         // This region contains more than one rectangle.
200         assertFalse(mRegion.quickContains(rect));
201     }
202 
testQuickContains2()203     public void testQuickContains2() {
204 
205         mRegion = new Region();
206         // This region not contains expected rectangle.
207         assertFalse(mRegion.quickContains(1, 2, 3, 4));
208         mRegion.set(1, 2, 3, 4);
209         // This region contains only one rectangle and it is the expected one.
210         assertTrue(mRegion.quickContains(1, 2, 3, 4));
211         mRegion.set(5, 6, 7, 8);
212         // This region contains more than one rectangle.
213         assertFalse(mRegion.quickContains(1, 2, 3, 4));
214     }
215 
testUnion()216     public void testUnion() {
217 
218         Rect rect1 = new Rect();
219         Rect rect2 = new Rect(0, 0, 20, 20);
220         Rect rect3 = new Rect(5, 5, 10, 10);
221         Rect rect4 = new Rect(10, 10, 30, 30);
222         Rect rect5 = new Rect(40, 40, 60, 60);
223 
224         // union (inclusive-or) the two regions
225         mRegion = null;
226         mRegion = new Region();
227         mRegion.set(rect2);
228         // union null rectangle
229         assertTrue(mRegion.contains(6, 6));
230         assertTrue(mRegion.union(rect1));
231         assertTrue(mRegion.contains(6, 6));
232 
233         // 1. union rectangle inside this region
234         mRegion.set(rect2);
235         assertTrue(mRegion.contains(2, 2));
236         assertTrue(mRegion.contains(6, 6));
237         assertTrue(mRegion.union(rect3));
238         assertPointsInsideRegion(UNION_WITH1);
239         assertPointsOutsideRegion(UNION_WITHOUT1);
240 
241         // 2. union rectangle overlap this region
242         mRegion.set(rect2);
243         assertTrue(mRegion.contains(2, 2));
244         assertFalse(mRegion.contains(21, 21));
245         assertTrue(mRegion.union(rect4));
246         assertPointsInsideRegion(UNION_WITH2);
247         assertPointsOutsideRegion(UNION_WITHOUT2);
248 
249         // 3. union rectangle out of this region
250         mRegion.set(rect2);
251         assertTrue(mRegion.contains(2, 2));
252         assertFalse(mRegion.contains(41, 41));
253         assertTrue(mRegion.union(rect5));
254         assertPointsInsideRegion(UNION_WITH3);
255         assertPointsOutsideRegion(UNION_WITHOUT3);
256     }
257 
testContains()258     public void testContains() {
259 
260         mRegion = new Region();
261         mRegion.set(2, 2, 5, 5);
262         // Not contain (1, 1).
263         assertFalse(mRegion.contains(1, 1));
264 
265         // Test point inside this region.
266         assertTrue(mRegion.contains(3, 3));
267 
268         // Test left-top corner.
269         assertTrue(mRegion.contains(2, 2));
270 
271         // Test left-bottom corner.
272         assertTrue(mRegion.contains(2, 4));
273 
274         // Test right-top corner.
275         assertTrue(mRegion.contains(4, 2));
276 
277         // Test right-bottom corner.
278         assertTrue(mRegion.contains(4, 4));
279 
280         // Though you set 5, but 5 is not contained by this region.
281         assertFalse(mRegion.contains(5, 5));
282         assertFalse(mRegion.contains(2, 5));
283         assertFalse(mRegion.contains(5, 2));
284 
285         // Set a new rectangle.
286         mRegion.set(6, 6, 8, 8);
287         assertFalse(mRegion.contains(3, 3));
288         assertTrue(mRegion.contains(7, 7));
289     }
290 
testEmpty()291     public void testEmpty() {
292 
293         mRegion = new Region();
294         assertTrue(mRegion.isEmpty());
295         mRegion = null;
296         mRegion = new Region(1, 2, 3, 4);
297         assertFalse(mRegion.isEmpty());
298         mRegion.setEmpty();
299         assertTrue(mRegion.isEmpty());
300     }
301 
testGetBounds()302     public void testGetBounds() {
303 
304         // Exception
305         try {
306             mRegion.getBounds(null);
307             fail("Should throw NullPointerException!");
308         } catch (NullPointerException e) {
309             //except here
310         }
311 
312         // Normal, return true.
313         Rect rect1 = new Rect(1, 2, 3, 4);
314         mRegion = new Region(rect1);
315         assertTrue(mRegion.getBounds(rect1));
316 
317         mRegion.setEmpty();
318         Rect rect2 = new Rect(5, 6, 7, 8);
319         assertFalse(mRegion.getBounds(rect2));
320     }
321 
testOp1()322     public void testOp1() {
323 
324         Rect rect1 = new Rect();
325         Rect rect2 = new Rect(0, 0, 20, 20);
326         Rect rect3 = new Rect(5, 5, 10, 10);
327         Rect rect4 = new Rect(10, 10, 30, 30);
328         Rect rect5 = new Rect(40, 40, 60, 60);
329 
330         assertNullRegionOp1(rect1);
331         assertDifferenceOp1(rect1, rect2, rect3, rect4, rect5);
332         assertIntersectOp1(rect1, rect2, rect3, rect4, rect5);
333         assertUnionOp1(rect1, rect2, rect3, rect4, rect5);
334         assertXorOp1(rect1, rect2, rect3, rect4, rect5);
335         assertReverseDifferenceOp1(rect1, rect2, rect3, rect4, rect5);
336         assertReplaceOp1(rect1, rect2, rect3, rect4, rect5);
337     }
338 
assertNullRegionOp1(Rect rect1)339     private void assertNullRegionOp1(Rect rect1) {
340         // Region without rectangle
341         mRegion = null;
342         mRegion = new Region();
343         assertFalse(mRegion.op(rect1, Region.Op.DIFFERENCE));
344         assertFalse(mRegion.op(rect1, Region.Op.INTERSECT));
345         assertFalse(mRegion.op(rect1, Region.Op.UNION));
346         assertFalse(mRegion.op(rect1, Region.Op.XOR));
347         assertFalse(mRegion.op(rect1, Region.Op.REVERSE_DIFFERENCE));
348         assertFalse(mRegion.op(rect1, Region.Op.REPLACE));
349     }
350 
assertDifferenceOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, Rect rect5)351     private void assertDifferenceOp1(Rect rect1, Rect rect2, Rect rect3,
352             Rect rect4, Rect rect5) {
353         // DIFFERENCE, Region with rectangle
354         // subtract the op region from the first region
355         mRegion = null;
356         mRegion = new Region();
357         // subtract null rectangle
358         mRegion.set(rect2);
359         assertTrue(mRegion.op(rect1, Region.Op.DIFFERENCE));
360 
361         // 1. subtract rectangle inside this region
362         mRegion.set(rect2);
363         assertTrue(mRegion.contains(6, 6));
364         assertTrue(mRegion.op(rect3, Region.Op.DIFFERENCE));
365         assertPointsInsideRegion(DIFFERENCE_WITH1);
366         assertPointsOutsideRegion(DIFFERENCE_WITHOUT1);
367 
368         // 2. subtract rectangle overlap this region
369         mRegion.set(rect2);
370         assertTrue(mRegion.contains(11, 11));
371         assertTrue(mRegion.op(rect4, Region.Op.DIFFERENCE));
372         assertPointsInsideRegion(DIFFERENCE_WITH2);
373         assertPointsOutsideRegion(DIFFERENCE_WITHOUT2);
374 
375         // 3. subtract rectangle out of this region
376         mRegion.set(rect2);
377         assertTrue(mRegion.op(rect5, Region.Op.DIFFERENCE));
378         assertPointsInsideRegion(DIFFERENCE_WITH3);
379         assertPointsOutsideRegion(DIFFERENCE_WITHOUT3);
380     }
381 
assertIntersectOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, Rect rect5)382     private void assertIntersectOp1(Rect rect1, Rect rect2, Rect rect3,
383             Rect rect4, Rect rect5) {
384         // INTERSECT, Region with rectangle
385         // intersect the two regions
386         mRegion = null;
387         mRegion = new Region();
388         // intersect null rectangle
389         mRegion.set(rect2);
390         assertFalse(mRegion.op(rect1, Region.Op.INTERSECT));
391 
392         // 1. intersect rectangle inside this region
393         mRegion.set(rect2);
394         assertTrue(mRegion.contains(2, 2));
395         assertTrue(mRegion.op(rect3, Region.Op.INTERSECT));
396         assertPointsInsideRegion(INTERSECT_WITH1);
397         assertPointsOutsideRegion(INTERSECT_WITHOUT1);
398 
399         // 2. intersect rectangle overlap this region
400         mRegion.set(rect2);
401         assertTrue(mRegion.contains(9, 9));
402         assertTrue(mRegion.op(rect4, Region.Op.INTERSECT));
403         assertPointsInsideRegion(INTERSECT_WITH2);
404         assertPointsOutsideRegion(INTERSECT_WITHOUT2);
405 
406         // 3. intersect rectangle out of this region
407         mRegion.set(rect2);
408         assertFalse(mRegion.op(rect5, Region.Op.INTERSECT));
409     }
410 
assertUnionOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, Rect rect5)411     private void assertUnionOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4,
412             Rect rect5) {
413         // UNION, Region with rectangle
414         // union (inclusive-or) the two regions
415         mRegion = null;
416         mRegion = new Region();
417         mRegion.set(rect2);
418         // union null rectangle
419         assertTrue(mRegion.contains(6, 6));
420         assertTrue(mRegion.op(rect1, Region.Op.UNION));
421         assertTrue(mRegion.contains(6, 6));
422 
423         // 1. union rectangle inside this region
424         mRegion.set(rect2);
425         assertTrue(mRegion.contains(2, 2));
426         assertTrue(mRegion.contains(6, 6));
427         assertTrue(mRegion.op(rect3, Region.Op.UNION));
428         assertPointsInsideRegion(UNION_WITH1);
429         assertPointsOutsideRegion(UNION_WITHOUT1);
430 
431         // 2. union rectangle overlap this region
432         mRegion.set(rect2);
433         assertTrue(mRegion.contains(2, 2));
434         assertFalse(mRegion.contains(21, 21));
435         assertTrue(mRegion.op(rect4, Region.Op.UNION));
436         assertPointsInsideRegion(UNION_WITH2);
437         assertPointsOutsideRegion(UNION_WITHOUT2);
438 
439         // 3. union rectangle out of this region
440         mRegion.set(rect2);
441         assertTrue(mRegion.contains(2, 2));
442         assertFalse(mRegion.contains(41, 41));
443         assertTrue(mRegion.op(rect5, Region.Op.UNION));
444         assertPointsInsideRegion(UNION_WITH3);
445         assertPointsOutsideRegion(UNION_WITHOUT3);
446     }
447 
assertXorOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, Rect rect5)448     private void assertXorOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4,
449             Rect rect5) {
450         // XOR, Region with rectangle
451         // exclusive-or the two regions
452         mRegion = null;
453         mRegion = new Region();
454         // xor null rectangle
455         mRegion.set(rect2);
456         assertTrue(mRegion.op(rect1, Region.Op.XOR));
457 
458         // 1. xor rectangle inside this region
459         mRegion.set(rect2);
460         assertTrue(mRegion.contains(2, 2));
461         assertTrue(mRegion.contains(6, 6));
462         assertTrue(mRegion.op(rect3, Region.Op.XOR));
463         assertPointsInsideRegion(XOR_WITH1);
464         assertPointsOutsideRegion(XOR_WITHOUT1);
465 
466         // 2. xor rectangle overlap this region
467         mRegion.set(rect2);
468         assertTrue(mRegion.contains(2, 2));
469         assertTrue(mRegion.contains(11, 11));
470         assertFalse(mRegion.contains(21, 21));
471         assertTrue(mRegion.op(rect4, Region.Op.XOR));
472         assertPointsInsideRegion(XOR_WITH2);
473         assertPointsOutsideRegion(XOR_WITHOUT2);
474 
475         // 3. xor rectangle out of this region
476         mRegion.set(rect2);
477         assertTrue(mRegion.contains(2, 2));
478         assertFalse(mRegion.contains(41, 41));
479         assertTrue(mRegion.op(rect5, Region.Op.XOR));
480         assertPointsInsideRegion(XOR_WITH3);
481         assertPointsOutsideRegion(XOR_WITHOUT3);
482     }
483 
assertReverseDifferenceOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, Rect rect5)484     private void assertReverseDifferenceOp1(Rect rect1, Rect rect2, Rect rect3,
485             Rect rect4, Rect rect5) {
486         // REVERSE_DIFFERENCE, Region with rectangle
487         // reverse difference the first region from the op region
488         mRegion = null;
489         mRegion = new Region();
490         mRegion.set(rect2);
491         // reverse difference null rectangle
492         assertFalse(mRegion.op(rect1, Region.Op.REVERSE_DIFFERENCE));
493 
494         // 1. reverse difference rectangle inside this region
495         mRegion.set(rect2);
496         assertTrue(mRegion.contains(2, 2));
497         assertTrue(mRegion.contains(6, 6));
498         assertFalse(mRegion.op(rect3, Region.Op.REVERSE_DIFFERENCE));
499 
500         // 2. reverse difference rectangle overlap this region
501         mRegion.set(rect2);
502         assertTrue(mRegion.contains(2, 2));
503         assertTrue(mRegion.contains(11, 11));
504         assertFalse(mRegion.contains(21, 21));
505         assertTrue(mRegion.op(rect4, Region.Op.REVERSE_DIFFERENCE));
506         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2);
507         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2);
508 
509         // 3. reverse difference rectangle out of this region
510         mRegion.set(rect2);
511         assertTrue(mRegion.contains(2, 2));
512         assertFalse(mRegion.contains(41, 41));
513         assertTrue(mRegion.op(rect5, Region.Op.REVERSE_DIFFERENCE));
514         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3);
515         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3);
516     }
517 
assertReplaceOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, Rect rect5)518     private void assertReplaceOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4,
519             Rect rect5) {
520         // REPLACE, Region with rectangle
521         // replace the dst region with the op region
522         mRegion = null;
523         mRegion = new Region();
524         mRegion.set(rect2);
525         // subtract null rectangle
526         assertFalse(mRegion.op(rect1, Region.Op.REPLACE));
527         // subtract rectangle inside this region
528         mRegion.set(rect2);
529         assertEquals(rect2, mRegion.getBounds());
530         assertTrue(mRegion.op(rect3, Region.Op.REPLACE));
531         assertNotSame(rect2, mRegion.getBounds());
532         assertEquals(rect3, mRegion.getBounds());
533         // subtract rectangle overlap this region
534         mRegion.set(rect2);
535         assertEquals(rect2, mRegion.getBounds());
536         assertTrue(mRegion.op(rect4, Region.Op.REPLACE));
537         assertNotSame(rect2, mRegion.getBounds());
538         assertEquals(rect4, mRegion.getBounds());
539         // subtract rectangle out of this region
540         mRegion.set(rect2);
541         assertEquals(rect2, mRegion.getBounds());
542         assertTrue(mRegion.op(rect5, Region.Op.REPLACE));
543         assertNotSame(rect2, mRegion.getBounds());
544         assertEquals(rect5, mRegion.getBounds());
545     }
546 
testOp2()547     public void testOp2() {
548 
549         Rect rect2 = new Rect(0, 0, 20, 20);
550         Rect rect3 = new Rect(5, 5, 10, 10);
551         Rect rect4 = new Rect(10, 10, 30, 30);
552         Rect rect5 = new Rect(40, 40, 60, 60);
553 
554         assertNullRegionOp2();
555         assertDifferenceOp2(rect2);
556         assertIntersectOp2(rect2);
557         assertUnionOp2(rect2);
558         assertXorOp2(rect2);
559         assertReverseDifferenceOp2(rect2);
560         assertReplaceOp2(rect2, rect3, rect4, rect5);
561     }
562 
assertNullRegionOp2()563     private void assertNullRegionOp2() {
564         // Region without rectangle
565         mRegion = null;
566         mRegion = new Region();
567         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.DIFFERENCE));
568         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.INTERSECT));
569         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.UNION));
570         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.XOR));
571         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REVERSE_DIFFERENCE));
572         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REPLACE));
573     }
574 
assertDifferenceOp2(Rect rect2)575     private void assertDifferenceOp2(Rect rect2) {
576         // DIFFERENCE, Region with rectangle
577         // subtract the op region from the first region
578         mRegion = null;
579         mRegion = new Region();
580         // subtract null rectangle
581         mRegion.set(rect2);
582         assertTrue(mRegion.op(0, 0, 0, 0, Region.Op.DIFFERENCE));
583 
584         // 1. subtract rectangle inside this region
585         mRegion.set(rect2);
586         assertTrue(mRegion.contains(6, 6));
587         assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.DIFFERENCE));
588         assertPointsInsideRegion(DIFFERENCE_WITH1);
589         assertPointsOutsideRegion(DIFFERENCE_WITHOUT1);
590 
591         // 2. subtract rectangle overlap this region
592         mRegion.set(rect2);
593         assertTrue(mRegion.contains(11, 11));
594         assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.DIFFERENCE));
595         assertPointsInsideRegion(DIFFERENCE_WITH2);
596         assertPointsOutsideRegion(DIFFERENCE_WITHOUT2);
597 
598         // 3. subtract rectangle out of this region
599         mRegion.set(rect2);
600         assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.DIFFERENCE));
601         assertPointsInsideRegion(DIFFERENCE_WITH3);
602         assertPointsOutsideRegion(DIFFERENCE_WITHOUT3);
603     }
604 
assertIntersectOp2(Rect rect2)605     private void assertIntersectOp2(Rect rect2) {
606         // INTERSECT, Region with rectangle
607         // intersect the two regions
608         mRegion = null;
609         mRegion = new Region();
610         // intersect null rectangle
611         mRegion.set(rect2);
612         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.INTERSECT));
613 
614         // 1. intersect rectangle inside this region
615         mRegion.set(rect2);
616         assertTrue(mRegion.contains(2, 2));
617         assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.INTERSECT));
618         assertPointsInsideRegion(INTERSECT_WITH1);
619         assertPointsOutsideRegion(INTERSECT_WITHOUT1);
620 
621         // 2. intersect rectangle overlap this region
622         mRegion.set(rect2);
623         assertTrue(mRegion.contains(9, 9));
624         assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.INTERSECT));
625         assertPointsInsideRegion(INTERSECT_WITH2);
626         assertPointsOutsideRegion(INTERSECT_WITHOUT2);
627 
628         // 3. intersect rectangle out of this region
629         mRegion.set(rect2);
630         assertFalse(mRegion.op(40, 40, 60, 60, Region.Op.INTERSECT));
631     }
632 
assertUnionOp2(Rect rect2)633     private void assertUnionOp2(Rect rect2) {
634         // UNION, Region with rectangle
635         // union (inclusive-or) the two regions
636         mRegion = null;
637         mRegion = new Region();
638         mRegion.set(rect2);
639         // union null rectangle
640         assertTrue(mRegion.contains(6, 6));
641         assertTrue(mRegion.op(0, 0, 0, 0, Region.Op.UNION));
642         assertTrue(mRegion.contains(6, 6));
643 
644         // 1. union rectangle inside this region
645         mRegion.set(rect2);
646         assertTrue(mRegion.contains(2, 2));
647         assertTrue(mRegion.contains(6, 6));
648         assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.UNION));
649         assertPointsInsideRegion(UNION_WITH1);
650         assertPointsOutsideRegion(UNION_WITHOUT1);
651 
652         // 2. union rectangle overlap this region
653         mRegion.set(rect2);
654         assertTrue(mRegion.contains(2, 2));
655         assertFalse(mRegion.contains(21, 21));
656         assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.UNION));
657         assertPointsInsideRegion(UNION_WITH2);
658         assertPointsOutsideRegion(UNION_WITHOUT2);
659 
660         // 3. union rectangle out of this region
661         mRegion.set(rect2);
662         assertTrue(mRegion.contains(2, 2));
663         assertFalse(mRegion.contains(41, 41));
664         assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.UNION));
665         assertPointsInsideRegion(UNION_WITH3);
666         assertPointsOutsideRegion(UNION_WITHOUT3);
667     }
668 
assertXorOp2(Rect rect2)669     private void assertXorOp2(Rect rect2) {
670         // XOR, Region with rectangle
671         // exclusive-or the two regions
672         mRegion = null;
673         mRegion = new Region();
674         mRegion.set(rect2);
675         // xor null rectangle
676         assertTrue(mRegion.op(0, 0, 0, 0, Region.Op.XOR));
677 
678         // 1. xor rectangle inside this region
679         mRegion.set(rect2);
680         assertTrue(mRegion.contains(2, 2));
681         assertTrue(mRegion.contains(6, 6));
682         assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.XOR));
683         assertPointsInsideRegion(XOR_WITH1);
684         assertPointsOutsideRegion(XOR_WITHOUT1);
685 
686         // 2. xor rectangle overlap this region
687         mRegion.set(rect2);
688         assertTrue(mRegion.contains(2, 2));
689         assertTrue(mRegion.contains(11, 11));
690         assertFalse(mRegion.contains(21, 21));
691         assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.XOR));
692         assertPointsInsideRegion(XOR_WITH2);
693         assertPointsOutsideRegion(XOR_WITHOUT2);
694 
695         // 3. xor rectangle out of this region
696         mRegion.set(rect2);
697         assertTrue(mRegion.contains(2, 2));
698         assertFalse(mRegion.contains(41, 41));
699         assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.XOR));
700         assertPointsInsideRegion(XOR_WITH3);
701         assertPointsOutsideRegion(XOR_WITHOUT3);
702     }
703 
assertReverseDifferenceOp2(Rect rect2)704     private void assertReverseDifferenceOp2(Rect rect2) {
705         // REVERSE_DIFFERENCE, Region with rectangle
706         // reverse difference the first region from the op region
707         mRegion = null;
708         mRegion = new Region();
709         mRegion.set(rect2);
710         // reverse difference null rectangle
711         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REVERSE_DIFFERENCE));
712         // reverse difference rectangle inside this region
713         mRegion.set(rect2);
714         assertTrue(mRegion.contains(2, 2));
715         assertTrue(mRegion.contains(6, 6));
716         assertFalse(mRegion.op(5, 5, 10, 10, Region.Op.REVERSE_DIFFERENCE));
717         // reverse difference rectangle overlap this region
718         mRegion.set(rect2);
719         assertTrue(mRegion.contains(2, 2));
720         assertTrue(mRegion.contains(11, 11));
721         assertFalse(mRegion.contains(21, 21));
722         assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.REVERSE_DIFFERENCE));
723         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2);
724         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2);
725         // reverse difference rectangle out of this region
726         mRegion.set(rect2);
727         assertTrue(mRegion.contains(2, 2));
728         assertFalse(mRegion.contains(41, 41));
729         assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.REVERSE_DIFFERENCE));
730         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3);
731         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3);
732     }
733 
assertReplaceOp2(Rect rect2, Rect rect3, Rect rect4, Rect rect5)734     private void assertReplaceOp2(Rect rect2, Rect rect3, Rect rect4, Rect rect5) {
735         // REPLACE, Region w1ith rectangle
736         // replace the dst region with the op region
737         mRegion = null;
738         mRegion = new Region();
739         mRegion.set(rect2);
740         // subtract null rectangle
741         assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REPLACE));
742         // subtract rectangle inside this region
743         mRegion.set(rect2);
744         assertEquals(rect2, mRegion.getBounds());
745         assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.REPLACE));
746         assertNotSame(rect2, mRegion.getBounds());
747         assertEquals(rect3, mRegion.getBounds());
748         // subtract rectangle overlap this region
749         mRegion.set(rect2);
750         assertEquals(rect2, mRegion.getBounds());
751         assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.REPLACE));
752         assertNotSame(rect2, mRegion.getBounds());
753         assertEquals(rect4, mRegion.getBounds());
754         // subtract rectangle out of this region
755         mRegion.set(rect2);
756         assertEquals(rect2, mRegion.getBounds());
757         assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.REPLACE));
758         assertNotSame(rect2, mRegion.getBounds());
759         assertEquals(rect5, mRegion.getBounds());
760     }
761 
testOp3()762     public void testOp3() {
763 
764         Region region1 = new Region();
765         Region region2 = new Region(0, 0, 20, 20);
766         Region region3 = new Region(5, 5, 10, 10);
767         Region region4 = new Region(10, 10, 30, 30);
768         Region region5 = new Region(40, 40, 60, 60);
769 
770         assertNullRegionOp3(region1);
771         assertDifferenceOp3(region1, region2, region3, region4, region5);
772         assertIntersectOp3(region1, region2, region3, region4, region5);
773         assertUnionOp3(region1, region2, region3, region4, region5);
774         assertXorOp3(region1, region2, region3, region4, region5);
775         assertReverseDifferenceOp3(region1, region2, region3, region4, region5);
776         assertReplaceOp3(region1, region2, region3, region4, region5);
777     }
778 
assertNullRegionOp3(Region region1)779     private void assertNullRegionOp3(Region region1) {
780         // Region without rectangle
781         mRegion = null;
782         mRegion = new Region();
783         assertFalse(mRegion.op(region1, Region.Op.DIFFERENCE));
784         assertFalse(mRegion.op(region1, Region.Op.INTERSECT));
785         assertFalse(mRegion.op(region1, Region.Op.UNION));
786         assertFalse(mRegion.op(region1, Region.Op.XOR));
787         assertFalse(mRegion.op(region1, Region.Op.REVERSE_DIFFERENCE));
788         assertFalse(mRegion.op(region1, Region.Op.REPLACE));
789     }
790 
assertDifferenceOp3(Region region1, Region region2, Region region3, Region region4, Region region5)791     private void assertDifferenceOp3(Region region1, Region region2,
792             Region region3, Region region4, Region region5) {
793         // DIFFERENCE, Region with rectangle
794         // subtract the op region from the first region
795         mRegion = null;
796         mRegion = new Region();
797         // subtract null rectangle
798         mRegion.set(region2);
799         assertTrue(mRegion.op(region1, Region.Op.DIFFERENCE));
800 
801         // 1. subtract rectangle inside this region
802         mRegion.set(region2);
803         assertTrue(mRegion.contains(6, 6));
804         assertTrue(mRegion.op(region3, Region.Op.DIFFERENCE));
805         assertPointsInsideRegion(DIFFERENCE_WITH1);
806         assertPointsOutsideRegion(DIFFERENCE_WITHOUT1);
807 
808         // 2. subtract rectangle overlap this region
809         mRegion.set(region2);
810         assertTrue(mRegion.contains(11, 11));
811         assertTrue(mRegion.op(region4, Region.Op.DIFFERENCE));
812         assertPointsInsideRegion(DIFFERENCE_WITH2);
813         assertPointsOutsideRegion(DIFFERENCE_WITHOUT2);
814 
815         // 3. subtract rectangle out of this region
816         mRegion.set(region2);
817         assertTrue(mRegion.op(region5, Region.Op.DIFFERENCE));
818         assertPointsInsideRegion(DIFFERENCE_WITH3);
819         assertPointsOutsideRegion(DIFFERENCE_WITHOUT3);
820     }
821 
assertIntersectOp3(Region region1, Region region2, Region region3, Region region4, Region region5)822     private void assertIntersectOp3(Region region1, Region region2,
823             Region region3, Region region4, Region region5) {
824         // INTERSECT, Region with rectangle
825         // intersect the two regions
826         mRegion = null;
827         mRegion = new Region();
828         mRegion.set(region2);
829         // intersect null rectangle
830         assertFalse(mRegion.op(region1, Region.Op.INTERSECT));
831 
832         // 1. intersect rectangle inside this region
833         mRegion.set(region2);
834         assertTrue(mRegion.contains(2, 2));
835         assertTrue(mRegion.op(region3, Region.Op.INTERSECT));
836         assertPointsInsideRegion(INTERSECT_WITH1);
837         assertPointsOutsideRegion(INTERSECT_WITHOUT1);
838 
839         // 2. intersect rectangle overlap this region
840         mRegion.set(region2);
841         assertTrue(mRegion.contains(9, 9));
842         assertTrue(mRegion.op(region4, Region.Op.INTERSECT));
843         assertPointsInsideRegion(INTERSECT_WITH2);
844         assertPointsOutsideRegion(INTERSECT_WITHOUT2);
845 
846         // 3. intersect rectangle out of this region
847         mRegion.set(region2);
848         assertFalse(mRegion.op(region5, Region.Op.INTERSECT));
849     }
850 
assertUnionOp3(Region region1, Region region2, Region region3, Region region4, Region region5)851     private void assertUnionOp3(Region region1, Region region2, Region region3,
852             Region region4, Region region5) {
853         // UNION, Region with rectangle
854         // union (inclusive-or) the two regions
855         mRegion = null;
856         mRegion = new Region();
857         // union null rectangle
858         mRegion.set(region2);
859         assertTrue(mRegion.contains(6, 6));
860         assertTrue(mRegion.op(region1, Region.Op.UNION));
861         assertTrue(mRegion.contains(6, 6));
862 
863         // 1. union rectangle inside this region
864         mRegion.set(region2);
865         assertTrue(mRegion.contains(2, 2));
866         assertTrue(mRegion.contains(6, 6));
867         assertTrue(mRegion.op(region3, Region.Op.UNION));
868         assertPointsInsideRegion(UNION_WITH1);
869         assertPointsOutsideRegion(UNION_WITHOUT1);
870 
871         // 2. union rectangle overlap this region
872         mRegion.set(region2);
873         assertTrue(mRegion.contains(2, 2));
874         assertFalse(mRegion.contains(21, 21));
875         assertTrue(mRegion.op(region4, Region.Op.UNION));
876         assertPointsInsideRegion(UNION_WITH2);
877         assertPointsOutsideRegion(UNION_WITHOUT2);
878 
879         // 3. union rectangle out of this region
880         mRegion.set(region2);
881         assertTrue(mRegion.contains(2, 2));
882         assertFalse(mRegion.contains(41, 41));
883         assertTrue(mRegion.op(region5, Region.Op.UNION));
884         assertPointsInsideRegion(UNION_WITH3);
885         assertPointsOutsideRegion(UNION_WITHOUT3);
886     }
887 
assertXorOp3(Region region1, Region region2, Region region3, Region region4, Region region5)888     private void assertXorOp3(Region region1, Region region2, Region region3,
889             Region region4, Region region5) {
890         // XOR, Region with rectangle
891         // exclusive-or the two regions
892         mRegion = null;
893         mRegion = new Region();
894         // xor null rectangle
895         mRegion.set(region2);
896         assertTrue(mRegion.op(region1, Region.Op.XOR));
897 
898         // 1. xor rectangle inside this region
899         mRegion.set(region2);
900         assertTrue(mRegion.contains(2, 2));
901         assertTrue(mRegion.contains(6, 6));
902         assertTrue(mRegion.op(region3, Region.Op.XOR));
903         assertPointsInsideRegion(XOR_WITH1);
904         assertPointsOutsideRegion(XOR_WITHOUT1);
905 
906         // 2. xor rectangle overlap this region
907         mRegion.set(region2);
908         assertTrue(mRegion.contains(2, 2));
909         assertTrue(mRegion.contains(11, 11));
910         assertFalse(mRegion.contains(21, 21));
911         assertTrue(mRegion.op(region4, Region.Op.XOR));
912         assertPointsInsideRegion(XOR_WITH2);
913         assertPointsOutsideRegion(XOR_WITHOUT2);
914 
915         // 3. xor rectangle out of this region
916         mRegion.set(region2);
917         assertTrue(mRegion.contains(2, 2));
918         assertFalse(mRegion.contains(41, 41));
919         assertTrue(mRegion.op(region5, Region.Op.XOR));
920         assertPointsInsideRegion(XOR_WITH3);
921         assertPointsOutsideRegion(XOR_WITHOUT3);
922     }
923 
assertReverseDifferenceOp3(Region region1, Region region2, Region region3, Region region4, Region region5)924     private void assertReverseDifferenceOp3(Region region1, Region region2,
925             Region region3, Region region4, Region region5) {
926         // REVERSE_DIFFERENCE, Region with rectangle
927         // reverse difference the first region from the op region
928         mRegion = null;
929         mRegion = new Region();
930         // reverse difference null rectangle
931         mRegion.set(region2);
932         assertFalse(mRegion.op(region1, Region.Op.REVERSE_DIFFERENCE));
933 
934         // 1. reverse difference rectangle inside this region
935         mRegion.set(region2);
936         assertTrue(mRegion.contains(2, 2));
937         assertTrue(mRegion.contains(6, 6));
938         assertFalse(mRegion.op(region3, Region.Op.REVERSE_DIFFERENCE));
939 
940         // 2. reverse difference rectangle overlap this region
941         mRegion.set(region2);
942         assertTrue(mRegion.contains(2, 2));
943         assertTrue(mRegion.contains(11, 11));
944         assertFalse(mRegion.contains(21, 21));
945         assertTrue(mRegion.op(region4, Region.Op.REVERSE_DIFFERENCE));
946         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2);
947         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2);
948 
949         // 3. reverse difference rectangle out of this region
950         mRegion.set(region2);
951         assertTrue(mRegion.contains(2, 2));
952         assertFalse(mRegion.contains(41, 41));
953         assertTrue(mRegion.op(region5, Region.Op.REVERSE_DIFFERENCE));
954         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3);
955         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3);
956     }
957 
assertReplaceOp3(Region region1, Region region2, Region region3, Region region4, Region region5)958     private void assertReplaceOp3(Region region1, Region region2, Region region3,
959             Region region4, Region region5) {
960         // REPLACE, Region with rectangle
961         // replace the dst region with the op region
962         mRegion = null;
963         mRegion = new Region();
964         mRegion.set(region2);
965         // subtract null rectangle
966         assertFalse(mRegion.op(region1, Region.Op.REPLACE));
967         // subtract rectangle inside this region
968         mRegion.set(region2);
969         assertEquals(region2.getBounds(), mRegion.getBounds());
970         assertTrue(mRegion.op(region3, Region.Op.REPLACE));
971         assertNotSame(region2.getBounds(), mRegion.getBounds());
972         assertEquals(region3.getBounds(), mRegion.getBounds());
973         // subtract rectangle overlap this region
974         mRegion.set(region2);
975         assertEquals(region2.getBounds(), mRegion.getBounds());
976         assertTrue(mRegion.op(region4, Region.Op.REPLACE));
977         assertNotSame(region2.getBounds(), mRegion.getBounds());
978         assertEquals(region4.getBounds(), mRegion.getBounds());
979         // subtract rectangle out of this region
980         mRegion.set(region2);
981         assertEquals(region2.getBounds(), mRegion.getBounds());
982         assertTrue(mRegion.op(region5, Region.Op.REPLACE));
983         assertNotSame(region2.getBounds(), mRegion.getBounds());
984         assertEquals(region5.getBounds(), mRegion.getBounds());
985     }
986 
testOp4()987     public void testOp4() {
988 
989         Rect rect1 = new Rect();
990         Rect rect2 = new Rect(0, 0, 20, 20);
991 
992         Region region1 = new Region();
993         Region region2 = new Region(0, 0, 20, 20);
994         Region region3 = new Region(5, 5, 10, 10);
995         Region region4 = new Region(10, 10, 30, 30);
996         Region region5 = new Region(40, 40, 60, 60);
997 
998         assertNullRegionOp4(rect1, region1);
999         assertDifferenceOp4(rect1, rect2, region1, region3, region4, region5);
1000         assertIntersectOp4(rect1, rect2, region1, region3, region4, region5);
1001         assertUnionOp4(rect1, rect2, region1, region3, region4, region5);
1002         assertXorOp4(rect1, rect2, region1, region3, region4, region5);
1003         assertReverseDifferenceOp4(rect1, rect2, region1, region3, region4,
1004                 region5);
1005         assertReplaceOp4(rect1, rect2, region1, region2, region3, region4,
1006                 region5);
1007     }
1008 
assertNullRegionOp4(Rect rect1, Region region1)1009     private void assertNullRegionOp4(Rect rect1, Region region1) {
1010         // Region without rectangle
1011         mRegion = null;
1012         mRegion = new Region();
1013         assertFalse(mRegion.op(rect1, region1, Region.Op.DIFFERENCE));
1014         assertFalse(mRegion.op(rect1, region1, Region.Op.INTERSECT));
1015         assertFalse(mRegion.op(rect1, region1, Region.Op.UNION));
1016 
1017         assertFalse(mRegion.op(rect1, region1, Region.Op.XOR));
1018         assertFalse(mRegion.op(rect1, region1, Region.Op.REVERSE_DIFFERENCE));
1019         assertFalse(mRegion.op(rect1, region1, Region.Op.REPLACE));
1020     }
1021 
assertDifferenceOp4(Rect rect1, Rect rect2, Region region1, Region region3, Region region4, Region region5)1022     private void assertDifferenceOp4(Rect rect1, Rect rect2, Region region1,
1023             Region region3, Region region4, Region region5) {
1024         // DIFFERENCE, Region with rectangle
1025         // subtract the op region from the first region
1026         mRegion = null;
1027         mRegion = new Region();
1028         // subtract null rectangle
1029         assertTrue(mRegion.op(rect2, region1, Region.Op.DIFFERENCE));
1030 
1031         // 1. subtract rectangle inside this region
1032         mRegion.set(rect1);
1033         assertTrue(mRegion.op(rect2, region3, Region.Op.DIFFERENCE));
1034         assertPointsInsideRegion(DIFFERENCE_WITH1);
1035         assertPointsOutsideRegion(DIFFERENCE_WITHOUT1);
1036 
1037         // 2. subtract rectangle overlap this region
1038         mRegion.set(rect1);
1039         assertTrue(mRegion.op(rect2, region4, Region.Op.DIFFERENCE));
1040         assertPointsInsideRegion(DIFFERENCE_WITH2);
1041         assertPointsOutsideRegion(DIFFERENCE_WITHOUT2);
1042 
1043         // 3. subtract rectangle out of this region
1044         mRegion.set(rect1);
1045         assertTrue(mRegion.op(rect2, region5, Region.Op.DIFFERENCE));
1046         assertPointsInsideRegion(DIFFERENCE_WITH3);
1047         assertPointsOutsideRegion(DIFFERENCE_WITHOUT3);
1048     }
1049 
assertIntersectOp4(Rect rect1, Rect rect2, Region region1, Region region3, Region region4, Region region5)1050     private void assertIntersectOp4(Rect rect1, Rect rect2, Region region1,
1051             Region region3, Region region4, Region region5) {
1052         // INTERSECT, Region with rectangle
1053         // intersect the two regions
1054         mRegion = null;
1055         mRegion = new Region();
1056         // intersect null rectangle
1057         mRegion.set(rect1);
1058         assertFalse(mRegion.op(rect2, region1, Region.Op.INTERSECT));
1059 
1060         // 1. intersect rectangle inside this region
1061         mRegion.set(rect1);
1062         assertTrue(mRegion.op(rect2, region3, Region.Op.INTERSECT));
1063         assertPointsInsideRegion(INTERSECT_WITH1);
1064         assertPointsOutsideRegion(INTERSECT_WITHOUT1);
1065 
1066         // 2. intersect rectangle overlap this region
1067         mRegion.set(rect1);
1068         assertTrue(mRegion.op(rect2, region4, Region.Op.INTERSECT));
1069         assertPointsInsideRegion(INTERSECT_WITH2);
1070         assertPointsOutsideRegion(INTERSECT_WITHOUT2);
1071 
1072         // 3. intersect rectangle out of this region
1073         mRegion.set(rect1);
1074         assertFalse(mRegion.op(rect2, region5, Region.Op.INTERSECT));
1075     }
1076 
assertUnionOp4(Rect rect1, Rect rect2, Region region1, Region region3, Region region4, Region region5)1077     private void assertUnionOp4(Rect rect1, Rect rect2, Region region1,
1078             Region region3, Region region4, Region region5) {
1079         // UNION, Region with rectangle
1080         // union (inclusive-or) the two regions
1081         mRegion = null;
1082         mRegion = new Region();
1083         // union null rectangle
1084         mRegion.set(rect1);
1085         assertTrue(mRegion.op(rect2, region1, Region.Op.UNION));
1086         assertTrue(mRegion.contains(6, 6));
1087 
1088         // 1. union rectangle inside this region
1089         mRegion.set(rect1);
1090         assertTrue(mRegion.op(rect2, region3, Region.Op.UNION));
1091         assertPointsInsideRegion(UNION_WITH1);
1092         assertPointsOutsideRegion(UNION_WITHOUT1);
1093 
1094         // 2. union rectangle overlap this region
1095         mRegion.set(rect1);
1096         assertTrue(mRegion.op(rect2, region4, Region.Op.UNION));
1097         assertPointsInsideRegion(UNION_WITH2);
1098         assertPointsOutsideRegion(UNION_WITHOUT2);
1099 
1100         // 3. union rectangle out of this region
1101         mRegion.set(rect1);
1102         assertTrue(mRegion.op(rect2, region5, Region.Op.UNION));
1103         assertPointsInsideRegion(UNION_WITH3);
1104         assertPointsOutsideRegion(UNION_WITHOUT3);
1105     }
1106 
assertXorOp4(Rect rect1, Rect rect2, Region region1, Region region3, Region region4, Region region5)1107     private void assertXorOp4(Rect rect1, Rect rect2, Region region1,
1108             Region region3, Region region4, Region region5) {
1109         // XOR, Region with rectangle
1110         // exclusive-or the two regions
1111         mRegion = null;
1112         mRegion = new Region();
1113         // xor null rectangle
1114         mRegion.set(rect1);
1115         assertTrue(mRegion.op(rect2, region1, Region.Op.XOR));
1116 
1117         // 1. xor rectangle inside this region
1118         mRegion.set(rect1);
1119         assertTrue(mRegion.op(rect2, region3, Region.Op.XOR));
1120         assertPointsInsideRegion(XOR_WITH1);
1121         assertPointsOutsideRegion(XOR_WITHOUT1);
1122 
1123         // 2. xor rectangle overlap this region
1124         mRegion.set(rect1);
1125         assertTrue(mRegion.op(rect2, region4, Region.Op.XOR));
1126         assertPointsInsideRegion(XOR_WITH2);
1127         assertPointsOutsideRegion(XOR_WITHOUT2);
1128 
1129         // 3. xor rectangle out of this region
1130         mRegion.set(rect1);
1131         assertTrue(mRegion.op(rect2, region5, Region.Op.XOR));
1132         assertPointsInsideRegion(XOR_WITH3);
1133         assertPointsOutsideRegion(XOR_WITHOUT3);
1134     }
1135 
assertReverseDifferenceOp4(Rect rect1, Rect rect2, Region region1, Region region3, Region region4, Region region5)1136     private void assertReverseDifferenceOp4(Rect rect1, Rect rect2,
1137             Region region1, Region region3, Region region4, Region region5) {
1138         // REVERSE_DIFFERENCE, Region with rectangle
1139         // reverse difference the first region from the op region
1140         mRegion = null;
1141         mRegion = new Region();
1142         // reverse difference null rectangle
1143         mRegion.set(rect1);
1144         assertFalse(mRegion.op(rect2, region1, Region.Op.REVERSE_DIFFERENCE));
1145 
1146         // 1. reverse difference rectangle inside this region
1147         mRegion.set(rect1);
1148         assertFalse(mRegion.op(rect2, region3, Region.Op.REVERSE_DIFFERENCE));
1149 
1150         // 2. reverse difference rectangle overlap this region
1151         mRegion.set(rect1);
1152         assertTrue(mRegion.op(rect2, region4, Region.Op.REVERSE_DIFFERENCE));
1153         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2);
1154         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2);
1155 
1156         // 3. reverse difference rectangle out of this region
1157         mRegion.set(rect1);
1158         assertTrue(mRegion.op(rect2, region5, Region.Op.REVERSE_DIFFERENCE));
1159         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3);
1160         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3);
1161     }
1162 
assertReplaceOp4(Rect rect1, Rect rect2, Region region1, Region region2, Region region3, Region region4, Region region5)1163     private void assertReplaceOp4(Rect rect1, Rect rect2, Region region1,
1164             Region region2, Region region3, Region region4, Region region5) {
1165         // REPLACE, Region with rectangle
1166         // replace the dst region with the op region
1167         mRegion = null;
1168         mRegion = new Region();
1169         // subtract null rectangle
1170         mRegion.set(rect1);
1171         assertFalse(mRegion.op(rect2, region1, Region.Op.REPLACE));
1172         // subtract rectangle inside this region
1173         mRegion.set(rect1);
1174         assertTrue(mRegion.op(rect2, region3, Region.Op.REPLACE));
1175         assertNotSame(region2.getBounds(), mRegion.getBounds());
1176         assertEquals(region3.getBounds(), mRegion.getBounds());
1177         // subtract rectangle overlap this region
1178         mRegion.set(rect1);
1179         assertTrue(mRegion.op(rect2, region4, Region.Op.REPLACE));
1180         assertNotSame(region2.getBounds(), mRegion.getBounds());
1181         assertEquals(region4.getBounds(), mRegion.getBounds());
1182         // subtract rectangle out of this region
1183         mRegion.set(rect1);
1184         assertTrue(mRegion.op(rect2, region5, Region.Op.REPLACE));
1185         assertNotSame(region2.getBounds(), mRegion.getBounds());
1186         assertEquals(region5.getBounds(), mRegion.getBounds());
1187     }
1188 
testOp5()1189     public void testOp5() {
1190 
1191         Region region1 = new Region();
1192         Region region2 = new Region(0, 0, 20, 20);
1193         Region region3 = new Region(5, 5, 10, 10);
1194         Region region4 = new Region(10, 10, 30, 30);
1195         Region region5 = new Region(40, 40, 60, 60);
1196 
1197         assertNullRegionOp5(region1);
1198         assertDifferenceOp5(region1, region2, region3, region4, region5);
1199         assertIntersectOp5(region1, region2, region3, region4, region5);
1200         assertUnionOp5(region1, region2, region3, region4, region5);
1201         assertXorOp5(region1, region2, region3, region4, region5);
1202         assertReverseDifferenceOp5(region1, region2, region3, region4, region5);
1203         assertReplaceOp5(region1, region2, region3, region4, region5);
1204     }
1205 
assertNullRegionOp5(Region region1)1206     private void assertNullRegionOp5(Region region1) {
1207         // Region without rectangle
1208         mRegion = null;
1209         mRegion = new Region();
1210         assertFalse(mRegion.op(mRegion, region1, Region.Op.DIFFERENCE));
1211         assertFalse(mRegion.op(mRegion, region1, Region.Op.INTERSECT));
1212         assertFalse(mRegion.op(mRegion, region1, Region.Op.UNION));
1213         assertFalse(mRegion.op(mRegion, region1, Region.Op.XOR));
1214         assertFalse(mRegion.op(mRegion, region1, Region.Op.REVERSE_DIFFERENCE));
1215         assertFalse(mRegion.op(mRegion, region1, Region.Op.REPLACE));
1216     }
1217 
assertDifferenceOp5(Region region1, Region region2, Region region3, Region region4, Region region5)1218     private void assertDifferenceOp5(Region region1, Region region2,
1219             Region region3, Region region4, Region region5) {
1220         // DIFFERENCE, Region with rectangle
1221         // subtract the op region from the first region
1222         mRegion = null;
1223         mRegion = new Region();
1224         // subtract null rectangle
1225         mRegion.set(region1);
1226         assertTrue(mRegion.op(region2, region1, Region.Op.DIFFERENCE));
1227 
1228         // 1. subtract rectangle inside this region
1229         mRegion.set(region1);
1230         assertTrue(mRegion.op(region2, region3, Region.Op.DIFFERENCE));
1231         assertPointsInsideRegion(DIFFERENCE_WITH1);
1232         assertPointsOutsideRegion(DIFFERENCE_WITHOUT1);
1233 
1234         // 2. subtract rectangle overlap this region
1235         mRegion.set(region1);
1236         assertTrue(mRegion.op(region2, region4, Region.Op.DIFFERENCE));
1237         assertPointsInsideRegion(DIFFERENCE_WITH2);
1238         assertPointsOutsideRegion(DIFFERENCE_WITHOUT2);
1239 
1240         // 3. subtract rectangle out of this region
1241         mRegion.set(region1);
1242         assertTrue(mRegion.op(region2, region5, Region.Op.DIFFERENCE));
1243         assertPointsInsideRegion(DIFFERENCE_WITH3);
1244         assertPointsOutsideRegion(DIFFERENCE_WITHOUT3);
1245     }
1246 
assertIntersectOp5(Region region1, Region region2, Region region3, Region region4, Region region5)1247     private void assertIntersectOp5(Region region1, Region region2,
1248             Region region3, Region region4, Region region5) {
1249         // INTERSECT, Region with rectangle
1250         // intersect the two regions
1251         mRegion = null;
1252         mRegion = new Region();
1253         // intersect null rectangle
1254         mRegion.set(region1);
1255         assertFalse(mRegion.op(region2, region1, Region.Op.INTERSECT));
1256 
1257         // 1. intersect rectangle inside this region
1258         mRegion.set(region1);
1259         assertTrue(mRegion.op(region2, region3, Region.Op.INTERSECT));
1260         assertPointsInsideRegion(INTERSECT_WITH1);
1261         assertPointsOutsideRegion(INTERSECT_WITHOUT1);
1262 
1263         // 2. intersect rectangle overlap this region
1264         mRegion.set(region1);
1265         assertTrue(mRegion.op(region2, region4, Region.Op.INTERSECT));
1266         assertPointsInsideRegion(INTERSECT_WITH2);
1267         assertPointsOutsideRegion(INTERSECT_WITHOUT2);
1268 
1269         // 3. intersect rectangle out of this region
1270         mRegion.set(region1);
1271         assertFalse(mRegion.op(region2, region5, Region.Op.INTERSECT));
1272     }
1273 
assertUnionOp5(Region region1, Region region2, Region region3, Region region4, Region region5)1274     private void assertUnionOp5(Region region1, Region region2,
1275             Region region3, Region region4, Region region5) {
1276         // UNION, Region with rectangle
1277         // union (inclusive-or) the two regions
1278         mRegion = null;
1279         mRegion = new Region();
1280         // union null rectangle
1281         mRegion.set(region1);
1282         assertTrue(mRegion.op(region2, region1, Region.Op.UNION));
1283         assertTrue(mRegion.contains(6, 6));
1284 
1285         // 1. union rectangle inside this region
1286         mRegion.set(region1);
1287         assertTrue(mRegion.op(region2, region3, Region.Op.UNION));
1288         assertPointsInsideRegion(UNION_WITH1);
1289         assertPointsOutsideRegion(UNION_WITHOUT1);
1290 
1291         // 2. union rectangle overlap this region
1292         mRegion.set(region1);
1293         assertTrue(mRegion.op(region2, region4, Region.Op.UNION));
1294         assertPointsInsideRegion(UNION_WITH2);
1295         assertPointsOutsideRegion(UNION_WITHOUT2);
1296 
1297         // 3. union rectangle out of this region
1298         mRegion.set(region1);
1299         assertTrue(mRegion.op(region2, region5, Region.Op.UNION));
1300         assertPointsInsideRegion(UNION_WITH3);
1301         assertPointsOutsideRegion(UNION_WITHOUT3);
1302     }
1303 
assertXorOp5(Region region1, Region region2, Region region3, Region region4, Region region5)1304     private void assertXorOp5(Region region1, Region region2,
1305             Region region3, Region region4, Region region5) {
1306         // XOR, Region with rectangle
1307         // exclusive-or the two regions
1308         mRegion = null;
1309         mRegion = new Region();
1310         // xor null rectangle
1311         mRegion.set(region1);
1312         assertTrue(mRegion.op(region2, region1, Region.Op.XOR));
1313 
1314         // 1. xor rectangle inside this region
1315         mRegion.set(region1);
1316         assertTrue(mRegion.op(region2, region3, Region.Op.XOR));
1317         assertPointsInsideRegion(XOR_WITH1);
1318         assertPointsOutsideRegion(XOR_WITHOUT1);
1319 
1320         // 2. xor rectangle overlap this region
1321         mRegion.set(region1);
1322         assertTrue(mRegion.op(region2, region4, Region.Op.XOR));
1323         assertPointsInsideRegion(XOR_WITH2);
1324         assertPointsOutsideRegion(XOR_WITHOUT2);
1325 
1326         // 3. xor rectangle out of this region
1327         mRegion.set(region1);
1328         assertTrue(mRegion.op(region2, region5, Region.Op.XOR));
1329         assertPointsInsideRegion(XOR_WITH3);
1330         assertPointsOutsideRegion(XOR_WITHOUT3);
1331     }
1332 
assertReverseDifferenceOp5(Region region1, Region region2, Region region3, Region region4, Region region5)1333     private void assertReverseDifferenceOp5(Region region1, Region region2,
1334             Region region3, Region region4, Region region5) {
1335         // REVERSE_DIFFERENCE, Region with rectangle
1336         // reverse difference the first region from the op region
1337         mRegion = null;
1338         mRegion = new Region();
1339         // reverse difference null rectangle
1340         mRegion.set(region1);
1341         assertFalse(mRegion.op(region2, region1, Region.Op.REVERSE_DIFFERENCE));
1342 
1343         // 1. reverse difference rectangle inside this region
1344         mRegion.set(region1);
1345         assertFalse(mRegion.op(region2, region3, Region.Op.REVERSE_DIFFERENCE));
1346 
1347         // 2. reverse difference rectangle overlap this region
1348         mRegion.set(region1);
1349         assertTrue(mRegion.op(region2, region4, Region.Op.REVERSE_DIFFERENCE));
1350         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2);
1351         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2);
1352 
1353         // 3. reverse difference rectangle out of this region
1354         mRegion.set(region1);
1355         assertTrue(mRegion.op(region2, region5, Region.Op.REVERSE_DIFFERENCE));
1356         assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3);
1357         assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3);
1358     }
1359 
assertReplaceOp5(Region region1, Region region2, Region region3, Region region4, Region region5)1360     private void assertReplaceOp5(Region region1, Region region2,
1361             Region region3, Region region4, Region region5) {
1362         // REPLACE, Region with rectangle
1363         // replace the dst region with the op region
1364         mRegion = null;
1365         mRegion = new Region();
1366         // subtract null rectangle
1367         mRegion.set(region1);
1368         assertFalse(mRegion.op(region2, region1, Region.Op.REPLACE));
1369         // subtract rectangle inside this region
1370         mRegion.set(region1);
1371         assertTrue(mRegion.op(region2, region3, Region.Op.REPLACE));
1372         assertNotSame(region2.getBounds(), mRegion.getBounds());
1373         assertEquals(region3.getBounds(), mRegion.getBounds());
1374         // subtract rectangle overlap this region
1375         mRegion.set(region1);
1376         assertTrue(mRegion.op(region2, region4, Region.Op.REPLACE));
1377         assertNotSame(region2.getBounds(), mRegion.getBounds());
1378         assertEquals(region4.getBounds(), mRegion.getBounds());
1379         // subtract rectangle out of this region
1380         mRegion.set(region1);
1381         assertTrue(mRegion.op(region2, region5, Region.Op.REPLACE));
1382         assertNotSame(region2.getBounds(), mRegion.getBounds());
1383         assertEquals(region5.getBounds(), mRegion.getBounds());
1384     }
1385 
testGetBoundaryPath1()1386     public void testGetBoundaryPath1() {
1387         mRegion = new Region();
1388         assertTrue(mRegion.getBoundaryPath().isEmpty());
1389 
1390         // Both clip and path are non-null.
1391         Region clip = new Region(0, 0, 10, 10);
1392         Path path = new Path();
1393         path.addRect(0, 0, 10, 10, Path.Direction.CW);
1394         assertTrue(mRegion.setPath(path, clip));
1395         assertFalse(mRegion.getBoundaryPath().isEmpty());
1396     }
1397 
testGetBoundaryPath2()1398     public void testGetBoundaryPath2() {
1399 
1400         mRegion = new Region();
1401         Path path = new Path();
1402         assertFalse(mRegion.getBoundaryPath(path));
1403 
1404         // path is null
1405         mRegion = new Region(0, 0, 10, 10);
1406         path = new Path();
1407         assertTrue(mRegion.getBoundaryPath(path));
1408 
1409         // region is null
1410         mRegion = new Region();
1411         path = new Path();
1412         path.addRect(0, 0, 10, 10, Path.Direction.CW);
1413         assertFalse(mRegion.getBoundaryPath(path));
1414 
1415         // both path and region are non-null
1416         mRegion = new Region(0, 0, 10, 10);
1417         path = new Path();
1418         path.addRect(0, 0, 5, 5, Path.Direction.CW);
1419         assertTrue(mRegion.getBoundaryPath(path));
1420     }
1421 
testSetPath()1422     public void testSetPath() {
1423 
1424         mRegion = new Region();
1425         // Both clip and path are null.
1426         Region clip = new Region();
1427         Path path = new Path();
1428         assertFalse(mRegion.setPath(path, clip));
1429 
1430         // Only path is null.
1431         path = new Path();
1432         clip = new Region(0, 0, 10, 10);
1433         assertFalse(mRegion.setPath(path, clip));
1434 
1435         // Only clip is null.
1436         clip = new Region();
1437         path = new Path();
1438         path.addRect(0, 0, 10, 10, Path.Direction.CW);
1439         assertFalse(mRegion.setPath(path, clip));
1440 
1441         // Both clip and path are non-null.
1442         clip = new Region();
1443         path = new Path();
1444         clip = new Region(0, 0, 10, 10);
1445         path.addRect(0, 0, 10, 10, Path.Direction.CW);
1446         assertTrue(mRegion.setPath(path, clip));
1447 
1448         // Both clip and path are non-null.
1449         path = new Path();
1450         clip = new Region(0, 0, 5, 5);
1451         path.addRect(0, 0, 10, 10, Path.Direction.CW);
1452         assertTrue(mRegion.setPath(path, clip));
1453         Rect expected = new Rect(0, 0, 5, 5);
1454         Rect unexpected = new Rect(0, 0, 10, 10);
1455         Rect actual = mRegion.getBounds();
1456         assertEquals(expected.right, actual.right);
1457         assertNotSame(unexpected.right, actual.right);
1458 
1459         // Both clip and path are non-null.
1460         path = new Path();
1461         clip = new Region(0, 0, 10, 10);
1462         path.addRect(0, 0, 5, 5, Path.Direction.CW);
1463         assertTrue(mRegion.setPath(path, clip));
1464         expected = new Rect(0, 0, 5, 5);
1465         unexpected = new Rect(0, 0, 10, 10);
1466         actual = mRegion.getBounds();
1467         assertEquals(expected.right, actual.right);
1468         assertNotSame(unexpected.right, actual.right);
1469     }
1470 
testTranslate1()1471     public void testTranslate1() {
1472 
1473         Rect rect1 = new Rect(0, 0, 20, 20);
1474         Rect rect2 = new Rect(10, 10, 30, 30);
1475         mRegion = new Region(0, 0, 20, 20);
1476         mRegion.translate(10, 10);
1477         assertNotSame(rect1, mRegion.getBounds());
1478         assertEquals(rect2, mRegion.getBounds());
1479     }
1480 
testTranslate2()1481     public void testTranslate2() {
1482 
1483         Region dst = new Region();
1484         Rect rect1 = new Rect(0, 0, 20, 20);
1485         Rect rect2 = new Rect(10, 10, 30, 30);
1486         mRegion = new Region(0, 0, 20, 20);
1487         mRegion.translate(10, 10, dst);
1488         assertEquals(rect1, mRegion.getBounds());
1489         assertNotSame(rect2, mRegion.getBounds());
1490         assertNotSame(rect1, dst.getBounds());
1491         assertEquals(rect2, dst.getBounds());
1492     }
1493 
testWriteToParcel()1494     public void testWriteToParcel() {
1495 
1496         int flags = 0;
1497         Rect oriRect = new Rect(0, 0, 10, 10);
1498         mRegion = new Region();
1499 
1500         Parcel p = Parcel.obtain();
1501         mRegion.writeToParcel(p, flags);
1502         assertEquals(8, p.dataSize());
1503 
1504         p = Parcel.obtain();
1505         mRegion.set(oriRect);
1506         mRegion.writeToParcel(p, flags);
1507         assertEquals(24, p.dataSize());
1508 
1509         p.setDataPosition(0);
1510         Region dst = Region.CREATOR.createFromParcel(p);
1511         assertEquals(oriRect.top, dst.getBounds().top);
1512         assertEquals(oriRect.left, dst.getBounds().left);
1513         assertEquals(oriRect.bottom, dst.getBounds().bottom);
1514         assertEquals(oriRect.right, dst.getBounds().right);
1515     }
1516 
testDescribeContents()1517     public void testDescribeContents() {
1518 
1519         mRegion = new Region();
1520         int actual = mRegion.describeContents();
1521         assertEquals(0, actual);
1522     }
1523 
testQuickReject1()1524     public void testQuickReject1() {
1525         Rect oriRect = new Rect(0, 0, 20, 20);
1526         Rect rect1 = new Rect();
1527         Rect rect2 = new Rect(40, 40, 60, 60);
1528         Rect rect3 = new Rect(0, 0, 10, 10);
1529         Rect rect4 = new Rect(10, 10, 30, 30);
1530 
1531         mRegion = new Region();
1532         // Return true if the region is empty
1533         assertTrue(mRegion.quickReject(rect1));
1534         mRegion.set(oriRect);
1535         assertTrue(mRegion.quickReject(rect2));
1536         mRegion.set(oriRect);
1537         assertFalse(mRegion.quickReject(rect3));
1538         mRegion.set(oriRect);
1539         assertFalse(mRegion.quickReject(rect4));
1540     }
1541 
testQuickReject2()1542     public void testQuickReject2() {
1543         mRegion = new Region();
1544         // Return true if the region is empty
1545         assertTrue(mRegion.quickReject(0, 0, 0, 0));
1546         mRegion.set(0, 0, 20, 20);
1547         assertTrue(mRegion.quickReject(40, 40, 60, 60));
1548         mRegion.set(0, 0, 20, 20);
1549         assertFalse(mRegion.quickReject(0, 0, 10, 10));
1550         mRegion.set(0, 0, 20, 20);
1551         assertFalse(mRegion.quickReject(10, 10, 30, 30));
1552     }
1553 
testQuickReject3()1554     public void testQuickReject3() {
1555         Region oriRegion = new Region(0, 0, 20, 20);
1556         Region region1 = new Region();
1557         Region region2 = new Region(40, 40, 60, 60);
1558         Region region3 = new Region(0, 0, 10, 10);
1559         Region region4 = new Region(10, 10, 30, 30);
1560 
1561         mRegion = new Region();
1562         // Return true if the region is empty
1563         assertTrue(mRegion.quickReject(region1));
1564         mRegion.set(oriRegion);
1565         assertTrue(mRegion.quickReject(region2));
1566         mRegion.set(oriRegion);
1567         assertFalse(mRegion.quickReject(region3));
1568         mRegion.set(oriRegion);
1569         assertFalse(mRegion.quickReject(region4));
1570     }
1571 
1572 }
1573