| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.graphics.cts; |
| |
| import android.graphics.Path; |
| import android.graphics.Rect; |
| import android.graphics.Region; |
| import android.os.Parcel; |
| import android.test.AndroidTestCase; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargetClass; |
| |
| @TestTargetClass(Region.class) |
| public class RegionTest extends AndroidTestCase { |
| |
| // DIFFERENCE |
| private final static int[][] DIFFERENCE_WITH1 = {{0, 0}, {4, 4}, |
| {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19}}; |
| private final static int[][] DIFFERENCE_WITHOUT1 = {{5, 5}, {9, 9}, |
| {9, 5}, {5, 9}}; |
| |
| private final static int[][] DIFFERENCE_WITH2 = {{0, 0}, {19, 0}, {9, 9}, |
| {19, 9}, {0, 19}, {9, 19}}; |
| private final static int[][] DIFFERENCE_WITHOUT2 = {{10, 10}, {19, 10}, |
| {10, 19}, {19, 19}, {29, 10}, {29, 29}, {10, 29}}; |
| |
| private final static int[][] DIFFERENCE_WITH3 = {{0, 0}, {19, 0}, {0, 19}, |
| {19, 19}}; |
| private final static int[][] DIFFERENCE_WITHOUT3 = {{40, 40}, {40, 59}, |
| {59, 40}, {59, 59}}; |
| |
| // INTERSECT |
| private final static int[][] INTERSECT_WITH1 = {{5, 5}, {9, 9}, |
| {9, 5}, {5, 9}}; |
| private final static int[][] INTERSECT_WITHOUT1 = {{0, 0}, {2, 2}, {4, 4}, |
| {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19}}; |
| |
| private final static int[][] INTERSECT_WITH2 = {{10, 10}, {19, 10}, |
| {10, 19}, {19, 19}}; |
| private final static int[][] INTERSECT_WITHOUT2 = {{0, 0}, {19, 0}, {9, 9}, |
| {19, 9}, {0, 19}, {9, 19}, {29, 10}, {29, 29}, {10, 29}}; |
| |
| // UNION |
| private final static int[][] UNION_WITH1 = {{0, 0}, {2, 2}, {4, 4}, {6, 6}, |
| {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19}, |
| {5, 5}, {9, 9}, {9, 5}, {5, 9}}; |
| private final static int[][] UNION_WITHOUT1 = {{0, 20}, {20, 20}, {20, 0}}; |
| |
| private final static int[][] UNION_WITH2 = { |
| {0, 0}, {2, 2}, {19, 0}, {9, 9}, {19, 9}, {0, 19}, {9, 19}, {21, 21}, |
| {10, 10}, {19, 10}, {10, 19}, {19, 19}, {29, 10}, {29, 29}, {10, 29}}; |
| private final static int[][] UNION_WITHOUT2 = { |
| {0, 29}, {0, 20}, {9, 29}, {9, 20}, |
| {29, 0}, {20, 0}, {29, 9}, {20, 9}}; |
| |
| private final static int[][] UNION_WITH3 = { |
| {0, 0}, {2, 2}, {19, 0}, {0, 19}, {19, 19}, |
| {40, 40}, {41, 41}, {40, 59}, {59, 40}, {59, 59}}; |
| private final static int[][] UNION_WITHOUT3 = {{20, 20}, {39, 39}}; |
| |
| // XOR |
| private final static int[][] XOR_WITH1 = {{0, 0}, {2, 2}, {4, 4}, |
| {10, 10}, {19, 19}, {19, 0}, {10, 4}, {4, 10}, {0, 19}}; |
| private final static int[][] XOR_WITHOUT1 = {{5, 5}, {6, 6}, {9, 9}, |
| {9, 5}, {5, 9}}; |
| |
| private final static int[][] XOR_WITH2 = { |
| {0, 0}, {2, 2}, {19, 0}, {9, 9}, {19, 9}, {0, 19}, {9, 19}, {21, 21}, |
| {29, 10}, {10, 29}, {20, 10}, {10, 20}, {20, 20}, {29, 29}}; |
| private final static int[][] XOR_WITHOUT2 = {{10, 10}, {11, 11}, {19, 10}, |
| {10, 19}, {19, 19}}; |
| |
| private final static int[][] XOR_WITH3 = { |
| {0, 0}, {2, 2}, {19, 0}, {0, 19}, {19, 19}, |
| {40, 40}, {41, 41}, {40, 59}, {59, 40}, {59, 59}}; |
| private final static int[][] XOR_WITHOUT3 = {{20, 20}, {39, 39}}; |
| |
| // REVERSE_DIFFERENCE |
| private final static int[][] REVERSE_DIFFERENCE_WITH2 = {{29, 10}, {10, 29}, |
| {20, 10}, {10, 20}, {20, 20}, {29, 29}, {21, 21}}; |
| private final static int[][] REVERSE_DIFFERENCE_WITHOUT2 = {{0, 0}, {19, 0}, |
| {0, 19}, {19, 19}, {2, 2}, {11, 11}}; |
| |
| private final static int[][] REVERSE_DIFFERENCE_WITH3 = {{40, 40}, {40, 59}, |
| {59, 40}, {59, 59}, {41, 41}}; |
| private final static int[][] REVERSE_DIFFERENCE_WITHOUT3 = {{0, 0}, {19, 0}, |
| {0, 19}, {19, 19}, {20, 20}, {39, 39}, {2, 2}}; |
| |
| private Region mRegion; |
| |
| private void assertPointsInsideRegion(int[][] area) { |
| for (int i = 0; i < area.length; i ++) { |
| assertTrue(mRegion.contains(area[i][0], area[i][1])); |
| } |
| } |
| |
| private void assertPointsOutsideRegion(int[][] area) { |
| for (int i = 0; i < area.length; i ++) { |
| assertFalse(mRegion.contains(area[i][0], area[i][1])); |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "Region", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "Region", |
| args = {android.graphics.Region.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "Region", |
| args = {android.graphics.Rect.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "Region", |
| args = {int.class, int.class, int.class, int.class} |
| ) |
| }) |
| public void testConstructor() { |
| // Test Region() |
| new Region(); |
| |
| // Test Region(Region) |
| Region oriRegion = new Region(); |
| new Region(oriRegion); |
| |
| // Test Region(Rect) |
| Rect rect = new Rect(); |
| new Region(rect); |
| |
| // Test Region(int, int, int, int) |
| new Region(0, 0, 100, 100); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "set", |
| args = {android.graphics.Region.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getBounds", |
| args = {} |
| ) |
| }) |
| public void testSet1() { |
| |
| mRegion = new Region(); |
| Rect rect = new Rect(1, 2, 3, 4); |
| Region oriRegion = new Region(rect); |
| assertTrue(mRegion.set(oriRegion)); |
| assertEquals(1, mRegion.getBounds().left); |
| assertEquals(2, mRegion.getBounds().top); |
| assertEquals(3, mRegion.getBounds().right); |
| assertEquals(4, mRegion.getBounds().bottom); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "set", |
| args = {android.graphics.Rect.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getBounds", |
| args = {} |
| ) |
| }) |
| public void testSet2() { |
| |
| mRegion = new Region(); |
| Rect rect = new Rect(1, 2, 3, 4); |
| assertTrue(mRegion.set(rect)); |
| assertEquals(1, mRegion.getBounds().left); |
| assertEquals(2, mRegion.getBounds().top); |
| assertEquals(3, mRegion.getBounds().right); |
| assertEquals(4, mRegion.getBounds().bottom); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "set", |
| args = {int.class, int.class, int.class, int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getBounds", |
| args = {} |
| ) |
| }) |
| public void testSet3() { |
| |
| mRegion = new Region(); |
| assertTrue(mRegion.set(1, 2, 3, 4)); |
| assertEquals(1, mRegion.getBounds().left); |
| assertEquals(2, mRegion.getBounds().top); |
| assertEquals(3, mRegion.getBounds().right); |
| assertEquals(4, mRegion.getBounds().bottom); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "isRect", |
| args = {} |
| ) |
| public void testIsRect() { |
| |
| mRegion = new Region(); |
| assertFalse(mRegion.isRect()); |
| mRegion = new Region(1, 2, 3, 4); |
| assertTrue(mRegion.isRect()); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "isComplex", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "set", |
| args = {int.class, int.class, int.class, int.class} |
| ) |
| }) |
| public void testIsComplex() { |
| |
| // Region is null |
| mRegion = new Region(); |
| assertFalse(mRegion.isComplex()); |
| |
| // Only one rectangle |
| mRegion = new Region(); |
| mRegion.set(1, 2, 3, 4); |
| assertFalse(mRegion.isComplex()); |
| |
| // More than one rectangle |
| mRegion = new Region(); |
| mRegion.set(1, 1, 2, 2); |
| mRegion.union(new Rect(3, 3, 5, 5)); |
| assertTrue(mRegion.isComplex()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "quickContains", |
| args = {android.graphics.Rect.class} |
| ) |
| public void testQuickContains1() { |
| |
| mRegion = new Region(); |
| Rect rect = new Rect(1, 2, 3, 4); |
| // This region not contains expected rectangle. |
| assertFalse(mRegion.quickContains(rect)); |
| mRegion.set(rect); |
| // This region contains only one rectangle and it is the expected one. |
| assertTrue(mRegion.quickContains(rect)); |
| mRegion.set(5, 6, 7, 8); |
| // This region contains more than one rectangle. |
| assertFalse(mRegion.quickContains(rect)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "quickContains", |
| args = {int.class, int.class, int.class, int.class} |
| ) |
| public void testQuickContains2() { |
| |
| mRegion = new Region(); |
| // This region not contains expected rectangle. |
| assertFalse(mRegion.quickContains(1, 2, 3, 4)); |
| mRegion.set(1, 2, 3, 4); |
| // This region contains only one rectangle and it is the expected one. |
| assertTrue(mRegion.quickContains(1, 2, 3, 4)); |
| mRegion.set(5, 6, 7, 8); |
| // This region contains more than one rectangle. |
| assertFalse(mRegion.quickContains(1, 2, 3, 4)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "union", |
| args = {android.graphics.Rect.class} |
| ) |
| public void testUnion() { |
| |
| Rect rect1 = new Rect(); |
| Rect rect2 = new Rect(0, 0, 20, 20); |
| Rect rect3 = new Rect(5, 5, 10, 10); |
| Rect rect4 = new Rect(10, 10, 30, 30); |
| Rect rect5 = new Rect(40, 40, 60, 60); |
| |
| // union (inclusive-or) the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // union null rectangle |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.union(rect1)); |
| assertTrue(mRegion.contains(6, 6)); |
| |
| // 1. union rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.union(rect3)); |
| assertPointsInsideRegion(UNION_WITH1); |
| assertPointsOutsideRegion(UNION_WITHOUT1); |
| |
| // 2. union rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.union(rect4)); |
| assertPointsInsideRegion(UNION_WITH2); |
| assertPointsOutsideRegion(UNION_WITHOUT2); |
| |
| // 3. union rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.union(rect5)); |
| assertPointsInsideRegion(UNION_WITH3); |
| assertPointsOutsideRegion(UNION_WITHOUT3); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "contains", |
| args = {int.class, int.class} |
| ) |
| public void testContains() { |
| |
| mRegion = new Region(); |
| mRegion.set(2, 2, 5, 5); |
| // Not contain (1, 1). |
| assertFalse(mRegion.contains(1, 1)); |
| |
| // Test point inside this region. |
| assertTrue(mRegion.contains(3, 3)); |
| |
| // Test left-top corner. |
| assertTrue(mRegion.contains(2, 2)); |
| |
| // Test left-bottom corner. |
| assertTrue(mRegion.contains(2, 4)); |
| |
| // Test right-top corner. |
| assertTrue(mRegion.contains(4, 2)); |
| |
| // Test right-bottom corner. |
| assertTrue(mRegion.contains(4, 4)); |
| |
| // Though you set 5, but 5 is not contained by this region. |
| assertFalse(mRegion.contains(5, 5)); |
| assertFalse(mRegion.contains(2, 5)); |
| assertFalse(mRegion.contains(5, 2)); |
| |
| // Set a new rectangle. |
| mRegion.set(6, 6, 8, 8); |
| assertFalse(mRegion.contains(3, 3)); |
| assertTrue(mRegion.contains(7, 7)); |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setEmpty", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "isEmpty", |
| args = {} |
| ) |
| }) |
| public void testEmpty() { |
| |
| mRegion = new Region(); |
| assertTrue(mRegion.isEmpty()); |
| mRegion = null; |
| mRegion = new Region(1, 2, 3, 4); |
| assertFalse(mRegion.isEmpty()); |
| mRegion.setEmpty(); |
| assertTrue(mRegion.isEmpty()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getBounds", |
| args = {android.graphics.Rect.class} |
| ) |
| public void testGetBounds() { |
| |
| // Exception |
| try { |
| mRegion.getBounds(null); |
| fail("Should throw NullPointerException!"); |
| } catch (NullPointerException e) { |
| //except here |
| } |
| |
| // Normal, return true. |
| Rect rect1 = new Rect(1, 2, 3, 4); |
| mRegion = new Region(rect1); |
| assertTrue(mRegion.getBounds(rect1)); |
| |
| mRegion.setEmpty(); |
| Rect rect2 = new Rect(5, 6, 7, 8); |
| assertFalse(mRegion.getBounds(rect2)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "op", |
| args = {android.graphics.Rect.class, android.graphics.Region.Op.class} |
| ) |
| public void testOp1() { |
| |
| Rect rect1 = new Rect(); |
| Rect rect2 = new Rect(0, 0, 20, 20); |
| Rect rect3 = new Rect(5, 5, 10, 10); |
| Rect rect4 = new Rect(10, 10, 30, 30); |
| Rect rect5 = new Rect(40, 40, 60, 60); |
| |
| assertNullRegionOp1(rect1); |
| assertDifferenceOp1(rect1, rect2, rect3, rect4, rect5); |
| assertIntersectOp1(rect1, rect2, rect3, rect4, rect5); |
| assertUnionOp1(rect1, rect2, rect3, rect4, rect5); |
| assertXorOp1(rect1, rect2, rect3, rect4, rect5); |
| assertReverseDifferenceOp1(rect1, rect2, rect3, rect4, rect5); |
| assertReplaceOp1(rect1, rect2, rect3, rect4, rect5); |
| } |
| |
| private void assertNullRegionOp1(Rect rect1) { |
| // Region without rectangle |
| mRegion = null; |
| mRegion = new Region(); |
| assertFalse(mRegion.op(rect1, Region.Op.DIFFERENCE)); |
| assertFalse(mRegion.op(rect1, Region.Op.INTERSECT)); |
| assertFalse(mRegion.op(rect1, Region.Op.UNION)); |
| assertFalse(mRegion.op(rect1, Region.Op.XOR)); |
| assertFalse(mRegion.op(rect1, Region.Op.REVERSE_DIFFERENCE)); |
| assertFalse(mRegion.op(rect1, Region.Op.REPLACE)); |
| } |
| |
| private void assertDifferenceOp1(Rect rect1, Rect rect2, Rect rect3, |
| Rect rect4, Rect rect5) { |
| // DIFFERENCE, Region with rectangle |
| // subtract the op region from the first region |
| mRegion = null; |
| mRegion = new Region(); |
| // subtract null rectangle |
| mRegion.set(rect2); |
| assertTrue(mRegion.op(rect1, Region.Op.DIFFERENCE)); |
| |
| // 1. subtract rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(rect3, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH1); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT1); |
| |
| // 2. subtract rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(11, 11)); |
| assertTrue(mRegion.op(rect4, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT2); |
| |
| // 3. subtract rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.op(rect5, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertIntersectOp1(Rect rect1, Rect rect2, Rect rect3, |
| Rect rect4, Rect rect5) { |
| // INTERSECT, Region with rectangle |
| // intersect the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // intersect null rectangle |
| mRegion.set(rect2); |
| assertFalse(mRegion.op(rect1, Region.Op.INTERSECT)); |
| |
| // 1. intersect rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.op(rect3, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH1); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT1); |
| |
| // 2. intersect rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(9, 9)); |
| assertTrue(mRegion.op(rect4, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH2); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT2); |
| |
| // 3. intersect rectangle out of this region |
| mRegion.set(rect2); |
| assertFalse(mRegion.op(rect5, Region.Op.INTERSECT)); |
| } |
| |
| private void assertUnionOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, |
| Rect rect5) { |
| // UNION, Region with rectangle |
| // union (inclusive-or) the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // union null rectangle |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(rect1, Region.Op.UNION)); |
| assertTrue(mRegion.contains(6, 6)); |
| |
| // 1. union rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(rect3, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH1); |
| assertPointsOutsideRegion(UNION_WITHOUT1); |
| |
| // 2. union rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(rect4, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH2); |
| assertPointsOutsideRegion(UNION_WITHOUT2); |
| |
| // 3. union rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(rect5, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH3); |
| assertPointsOutsideRegion(UNION_WITHOUT3); |
| } |
| |
| private void assertXorOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, |
| Rect rect5) { |
| // XOR, Region with rectangle |
| // exclusive-or the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // xor null rectangle |
| mRegion.set(rect2); |
| assertTrue(mRegion.op(rect1, Region.Op.XOR)); |
| |
| // 1. xor rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(rect3, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH1); |
| assertPointsOutsideRegion(XOR_WITHOUT1); |
| |
| // 2. xor rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(11, 11)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(rect4, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH2); |
| assertPointsOutsideRegion(XOR_WITHOUT2); |
| |
| // 3. xor rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(rect5, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH3); |
| assertPointsOutsideRegion(XOR_WITHOUT3); |
| } |
| |
| private void assertReverseDifferenceOp1(Rect rect1, Rect rect2, Rect rect3, |
| Rect rect4, Rect rect5) { |
| // REVERSE_DIFFERENCE, Region with rectangle |
| // reverse difference the first region from the op region |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // reverse difference null rectangle |
| assertFalse(mRegion.op(rect1, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 1. reverse difference rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertFalse(mRegion.op(rect3, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 2. reverse difference rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(11, 11)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(rect4, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2); |
| |
| // 3. reverse difference rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(rect5, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertReplaceOp1(Rect rect1, Rect rect2, Rect rect3, Rect rect4, |
| Rect rect5) { |
| // REPLACE, Region with rectangle |
| // replace the dst region with the op region |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // subtract null rectangle |
| assertFalse(mRegion.op(rect1, Region.Op.REPLACE)); |
| // subtract rectangle inside this region |
| mRegion.set(rect2); |
| assertEquals(rect2, mRegion.getBounds()); |
| assertTrue(mRegion.op(rect3, Region.Op.REPLACE)); |
| assertNotSame(rect2, mRegion.getBounds()); |
| assertEquals(rect3, mRegion.getBounds()); |
| // subtract rectangle overlap this region |
| mRegion.set(rect2); |
| assertEquals(rect2, mRegion.getBounds()); |
| assertTrue(mRegion.op(rect4, Region.Op.REPLACE)); |
| assertNotSame(rect2, mRegion.getBounds()); |
| assertEquals(rect4, mRegion.getBounds()); |
| // subtract rectangle out of this region |
| mRegion.set(rect2); |
| assertEquals(rect2, mRegion.getBounds()); |
| assertTrue(mRegion.op(rect5, Region.Op.REPLACE)); |
| assertNotSame(rect2, mRegion.getBounds()); |
| assertEquals(rect5, mRegion.getBounds()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "op", |
| args = {int.class, int.class, int.class, int.class, android.graphics.Region.Op.class} |
| ) |
| public void testOp2() { |
| |
| Rect rect2 = new Rect(0, 0, 20, 20); |
| Rect rect3 = new Rect(5, 5, 10, 10); |
| Rect rect4 = new Rect(10, 10, 30, 30); |
| Rect rect5 = new Rect(40, 40, 60, 60); |
| |
| assertNullRegionOp2(); |
| assertDifferenceOp2(rect2); |
| assertIntersectOp2(rect2); |
| assertUnionOp2(rect2); |
| assertXorOp2(rect2); |
| assertReverseDifferenceOp2(rect2); |
| assertReplaceOp2(rect2, rect3, rect4, rect5); |
| } |
| |
| private void assertNullRegionOp2() { |
| // Region without rectangle |
| mRegion = null; |
| mRegion = new Region(); |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.DIFFERENCE)); |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.INTERSECT)); |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.UNION)); |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.XOR)); |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REVERSE_DIFFERENCE)); |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REPLACE)); |
| } |
| |
| private void assertDifferenceOp2(Rect rect2) { |
| // DIFFERENCE, Region with rectangle |
| // subtract the op region from the first region |
| mRegion = null; |
| mRegion = new Region(); |
| // subtract null rectangle |
| mRegion.set(rect2); |
| assertTrue(mRegion.op(0, 0, 0, 0, Region.Op.DIFFERENCE)); |
| |
| // 1. subtract rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH1); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT1); |
| |
| // 2. subtract rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(11, 11)); |
| assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT2); |
| |
| // 3. subtract rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertIntersectOp2(Rect rect2) { |
| // INTERSECT, Region with rectangle |
| // intersect the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // intersect null rectangle |
| mRegion.set(rect2); |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.INTERSECT)); |
| |
| // 1. intersect rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH1); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT1); |
| |
| // 2. intersect rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(9, 9)); |
| assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH2); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT2); |
| |
| // 3. intersect rectangle out of this region |
| mRegion.set(rect2); |
| assertFalse(mRegion.op(40, 40, 60, 60, Region.Op.INTERSECT)); |
| } |
| |
| private void assertUnionOp2(Rect rect2) { |
| // UNION, Region with rectangle |
| // union (inclusive-or) the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // union null rectangle |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(0, 0, 0, 0, Region.Op.UNION)); |
| assertTrue(mRegion.contains(6, 6)); |
| |
| // 1. union rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH1); |
| assertPointsOutsideRegion(UNION_WITHOUT1); |
| |
| // 2. union rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH2); |
| assertPointsOutsideRegion(UNION_WITHOUT2); |
| |
| // 3. union rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH3); |
| assertPointsOutsideRegion(UNION_WITHOUT3); |
| } |
| |
| private void assertXorOp2(Rect rect2) { |
| // XOR, Region with rectangle |
| // exclusive-or the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // xor null rectangle |
| assertTrue(mRegion.op(0, 0, 0, 0, Region.Op.XOR)); |
| |
| // 1. xor rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH1); |
| assertPointsOutsideRegion(XOR_WITHOUT1); |
| |
| // 2. xor rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(11, 11)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH2); |
| assertPointsOutsideRegion(XOR_WITHOUT2); |
| |
| // 3. xor rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH3); |
| assertPointsOutsideRegion(XOR_WITHOUT3); |
| } |
| |
| private void assertReverseDifferenceOp2(Rect rect2) { |
| // REVERSE_DIFFERENCE, Region with rectangle |
| // reverse difference the first region from the op region |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // reverse difference null rectangle |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REVERSE_DIFFERENCE)); |
| // reverse difference rectangle inside this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertFalse(mRegion.op(5, 5, 10, 10, Region.Op.REVERSE_DIFFERENCE)); |
| // reverse difference rectangle overlap this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(11, 11)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2); |
| // reverse difference rectangle out of this region |
| mRegion.set(rect2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertReplaceOp2(Rect rect2, Rect rect3, Rect rect4, Rect rect5) { |
| // REPLACE, Region w1ith rectangle |
| // replace the dst region with the op region |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(rect2); |
| // subtract null rectangle |
| assertFalse(mRegion.op(0, 0, 0, 0, Region.Op.REPLACE)); |
| // subtract rectangle inside this region |
| mRegion.set(rect2); |
| assertEquals(rect2, mRegion.getBounds()); |
| assertTrue(mRegion.op(5, 5, 10, 10, Region.Op.REPLACE)); |
| assertNotSame(rect2, mRegion.getBounds()); |
| assertEquals(rect3, mRegion.getBounds()); |
| // subtract rectangle overlap this region |
| mRegion.set(rect2); |
| assertEquals(rect2, mRegion.getBounds()); |
| assertTrue(mRegion.op(10, 10, 30, 30, Region.Op.REPLACE)); |
| assertNotSame(rect2, mRegion.getBounds()); |
| assertEquals(rect4, mRegion.getBounds()); |
| // subtract rectangle out of this region |
| mRegion.set(rect2); |
| assertEquals(rect2, mRegion.getBounds()); |
| assertTrue(mRegion.op(40, 40, 60, 60, Region.Op.REPLACE)); |
| assertNotSame(rect2, mRegion.getBounds()); |
| assertEquals(rect5, mRegion.getBounds()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "op", |
| args = {android.graphics.Region.class, android.graphics.Region.Op.class} |
| ) |
| public void testOp3() { |
| |
| Region region1 = new Region(); |
| Region region2 = new Region(0, 0, 20, 20); |
| Region region3 = new Region(5, 5, 10, 10); |
| Region region4 = new Region(10, 10, 30, 30); |
| Region region5 = new Region(40, 40, 60, 60); |
| |
| assertNullRegionOp3(region1); |
| assertDifferenceOp3(region1, region2, region3, region4, region5); |
| assertIntersectOp3(region1, region2, region3, region4, region5); |
| assertUnionOp3(region1, region2, region3, region4, region5); |
| assertXorOp3(region1, region2, region3, region4, region5); |
| assertReverseDifferenceOp3(region1, region2, region3, region4, region5); |
| assertReplaceOp3(region1, region2, region3, region4, region5); |
| } |
| |
| private void assertNullRegionOp3(Region region1) { |
| // Region without rectangle |
| mRegion = null; |
| mRegion = new Region(); |
| assertFalse(mRegion.op(region1, Region.Op.DIFFERENCE)); |
| assertFalse(mRegion.op(region1, Region.Op.INTERSECT)); |
| assertFalse(mRegion.op(region1, Region.Op.UNION)); |
| assertFalse(mRegion.op(region1, Region.Op.XOR)); |
| assertFalse(mRegion.op(region1, Region.Op.REVERSE_DIFFERENCE)); |
| assertFalse(mRegion.op(region1, Region.Op.REPLACE)); |
| } |
| |
| private void assertDifferenceOp3(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // DIFFERENCE, Region with rectangle |
| // subtract the op region from the first region |
| mRegion = null; |
| mRegion = new Region(); |
| // subtract null rectangle |
| mRegion.set(region2); |
| assertTrue(mRegion.op(region1, Region.Op.DIFFERENCE)); |
| |
| // 1. subtract rectangle inside this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(region3, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH1); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT1); |
| |
| // 2. subtract rectangle overlap this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(11, 11)); |
| assertTrue(mRegion.op(region4, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT2); |
| |
| // 3. subtract rectangle out of this region |
| mRegion.set(region2); |
| assertTrue(mRegion.op(region5, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertIntersectOp3(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // INTERSECT, Region with rectangle |
| // intersect the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(region2); |
| // intersect null rectangle |
| assertFalse(mRegion.op(region1, Region.Op.INTERSECT)); |
| |
| // 1. intersect rectangle inside this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.op(region3, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH1); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT1); |
| |
| // 2. intersect rectangle overlap this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(9, 9)); |
| assertTrue(mRegion.op(region4, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH2); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT2); |
| |
| // 3. intersect rectangle out of this region |
| mRegion.set(region2); |
| assertFalse(mRegion.op(region5, Region.Op.INTERSECT)); |
| } |
| |
| private void assertUnionOp3(Region region1, Region region2, Region region3, |
| Region region4, Region region5) { |
| // UNION, Region with rectangle |
| // union (inclusive-or) the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // union null rectangle |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(region1, Region.Op.UNION)); |
| assertTrue(mRegion.contains(6, 6)); |
| |
| // 1. union rectangle inside this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(region3, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH1); |
| assertPointsOutsideRegion(UNION_WITHOUT1); |
| |
| // 2. union rectangle overlap this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(region4, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH2); |
| assertPointsOutsideRegion(UNION_WITHOUT2); |
| |
| // 3. union rectangle out of this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(region5, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH3); |
| assertPointsOutsideRegion(UNION_WITHOUT3); |
| } |
| |
| private void assertXorOp3(Region region1, Region region2, Region region3, |
| Region region4, Region region5) { |
| // XOR, Region with rectangle |
| // exclusive-or the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // xor null rectangle |
| mRegion.set(region2); |
| assertTrue(mRegion.op(region1, Region.Op.XOR)); |
| |
| // 1. xor rectangle inside this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertTrue(mRegion.op(region3, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH1); |
| assertPointsOutsideRegion(XOR_WITHOUT1); |
| |
| // 2. xor rectangle overlap this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(11, 11)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(region4, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH2); |
| assertPointsOutsideRegion(XOR_WITHOUT2); |
| |
| // 3. xor rectangle out of this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(region5, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH3); |
| assertPointsOutsideRegion(XOR_WITHOUT3); |
| } |
| |
| private void assertReverseDifferenceOp3(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // REVERSE_DIFFERENCE, Region with rectangle |
| // reverse difference the first region from the op region |
| mRegion = null; |
| mRegion = new Region(); |
| // reverse difference null rectangle |
| mRegion.set(region2); |
| assertFalse(mRegion.op(region1, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 1. reverse difference rectangle inside this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(6, 6)); |
| assertFalse(mRegion.op(region3, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 2. reverse difference rectangle overlap this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertTrue(mRegion.contains(11, 11)); |
| assertFalse(mRegion.contains(21, 21)); |
| assertTrue(mRegion.op(region4, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2); |
| |
| // 3. reverse difference rectangle out of this region |
| mRegion.set(region2); |
| assertTrue(mRegion.contains(2, 2)); |
| assertFalse(mRegion.contains(41, 41)); |
| assertTrue(mRegion.op(region5, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertReplaceOp3(Region region1, Region region2, Region region3, |
| Region region4, Region region5) { |
| // REPLACE, Region with rectangle |
| // replace the dst region with the op region |
| mRegion = null; |
| mRegion = new Region(); |
| mRegion.set(region2); |
| // subtract null rectangle |
| assertFalse(mRegion.op(region1, Region.Op.REPLACE)); |
| // subtract rectangle inside this region |
| mRegion.set(region2); |
| assertEquals(region2.getBounds(), mRegion.getBounds()); |
| assertTrue(mRegion.op(region3, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region3.getBounds(), mRegion.getBounds()); |
| // subtract rectangle overlap this region |
| mRegion.set(region2); |
| assertEquals(region2.getBounds(), mRegion.getBounds()); |
| assertTrue(mRegion.op(region4, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region4.getBounds(), mRegion.getBounds()); |
| // subtract rectangle out of this region |
| mRegion.set(region2); |
| assertEquals(region2.getBounds(), mRegion.getBounds()); |
| assertTrue(mRegion.op(region5, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region5.getBounds(), mRegion.getBounds()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "op", |
| args = {android.graphics.Rect.class, android.graphics.Region.class, |
| android.graphics.Region.Op.class} |
| ) |
| public void testOp4() { |
| |
| Rect rect1 = new Rect(); |
| Rect rect2 = new Rect(0, 0, 20, 20); |
| |
| Region region1 = new Region(); |
| Region region2 = new Region(0, 0, 20, 20); |
| Region region3 = new Region(5, 5, 10, 10); |
| Region region4 = new Region(10, 10, 30, 30); |
| Region region5 = new Region(40, 40, 60, 60); |
| |
| assertNullRegionOp4(rect1, region1); |
| assertDifferenceOp4(rect1, rect2, region1, region3, region4, region5); |
| assertIntersectOp4(rect1, rect2, region1, region3, region4, region5); |
| assertUnionOp4(rect1, rect2, region1, region3, region4, region5); |
| assertXorOp4(rect1, rect2, region1, region3, region4, region5); |
| assertReverseDifferenceOp4(rect1, rect2, region1, region3, region4, |
| region5); |
| assertReplaceOp4(rect1, rect2, region1, region2, region3, region4, |
| region5); |
| } |
| |
| private void assertNullRegionOp4(Rect rect1, Region region1) { |
| // Region without rectangle |
| mRegion = null; |
| mRegion = new Region(); |
| assertFalse(mRegion.op(rect1, region1, Region.Op.DIFFERENCE)); |
| assertFalse(mRegion.op(rect1, region1, Region.Op.INTERSECT)); |
| assertFalse(mRegion.op(rect1, region1, Region.Op.UNION)); |
| |
| assertFalse(mRegion.op(rect1, region1, Region.Op.XOR)); |
| assertFalse(mRegion.op(rect1, region1, Region.Op.REVERSE_DIFFERENCE)); |
| assertFalse(mRegion.op(rect1, region1, Region.Op.REPLACE)); |
| } |
| |
| private void assertDifferenceOp4(Rect rect1, Rect rect2, Region region1, |
| Region region3, Region region4, Region region5) { |
| // DIFFERENCE, Region with rectangle |
| // subtract the op region from the first region |
| mRegion = null; |
| mRegion = new Region(); |
| // subtract null rectangle |
| assertTrue(mRegion.op(rect2, region1, Region.Op.DIFFERENCE)); |
| |
| // 1. subtract rectangle inside this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region3, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH1); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT1); |
| |
| // 2. subtract rectangle overlap this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region4, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT2); |
| |
| // 3. subtract rectangle out of this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region5, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertIntersectOp4(Rect rect1, Rect rect2, Region region1, |
| Region region3, Region region4, Region region5) { |
| // INTERSECT, Region with rectangle |
| // intersect the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // intersect null rectangle |
| mRegion.set(rect1); |
| assertFalse(mRegion.op(rect2, region1, Region.Op.INTERSECT)); |
| |
| // 1. intersect rectangle inside this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region3, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH1); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT1); |
| |
| // 2. intersect rectangle overlap this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region4, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH2); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT2); |
| |
| // 3. intersect rectangle out of this region |
| mRegion.set(rect1); |
| assertFalse(mRegion.op(rect2, region5, Region.Op.INTERSECT)); |
| } |
| |
| private void assertUnionOp4(Rect rect1, Rect rect2, Region region1, |
| Region region3, Region region4, Region region5) { |
| // UNION, Region with rectangle |
| // union (inclusive-or) the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // union null rectangle |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region1, Region.Op.UNION)); |
| assertTrue(mRegion.contains(6, 6)); |
| |
| // 1. union rectangle inside this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region3, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH1); |
| assertPointsOutsideRegion(UNION_WITHOUT1); |
| |
| // 2. union rectangle overlap this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region4, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH2); |
| assertPointsOutsideRegion(UNION_WITHOUT2); |
| |
| // 3. union rectangle out of this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region5, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH3); |
| assertPointsOutsideRegion(UNION_WITHOUT3); |
| } |
| |
| private void assertXorOp4(Rect rect1, Rect rect2, Region region1, |
| Region region3, Region region4, Region region5) { |
| // XOR, Region with rectangle |
| // exclusive-or the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // xor null rectangle |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region1, Region.Op.XOR)); |
| |
| // 1. xor rectangle inside this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region3, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH1); |
| assertPointsOutsideRegion(XOR_WITHOUT1); |
| |
| // 2. xor rectangle overlap this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region4, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH2); |
| assertPointsOutsideRegion(XOR_WITHOUT2); |
| |
| // 3. xor rectangle out of this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region5, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH3); |
| assertPointsOutsideRegion(XOR_WITHOUT3); |
| } |
| |
| private void assertReverseDifferenceOp4(Rect rect1, Rect rect2, |
| Region region1, Region region3, Region region4, Region region5) { |
| // REVERSE_DIFFERENCE, Region with rectangle |
| // reverse difference the first region from the op region |
| mRegion = null; |
| mRegion = new Region(); |
| // reverse difference null rectangle |
| mRegion.set(rect1); |
| assertFalse(mRegion.op(rect2, region1, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 1. reverse difference rectangle inside this region |
| mRegion.set(rect1); |
| assertFalse(mRegion.op(rect2, region3, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 2. reverse difference rectangle overlap this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region4, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2); |
| |
| // 3. reverse difference rectangle out of this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region5, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertReplaceOp4(Rect rect1, Rect rect2, Region region1, |
| Region region2, Region region3, Region region4, Region region5) { |
| // REPLACE, Region with rectangle |
| // replace the dst region with the op region |
| mRegion = null; |
| mRegion = new Region(); |
| // subtract null rectangle |
| mRegion.set(rect1); |
| assertFalse(mRegion.op(rect2, region1, Region.Op.REPLACE)); |
| // subtract rectangle inside this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region3, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region3.getBounds(), mRegion.getBounds()); |
| // subtract rectangle overlap this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region4, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region4.getBounds(), mRegion.getBounds()); |
| // subtract rectangle out of this region |
| mRegion.set(rect1); |
| assertTrue(mRegion.op(rect2, region5, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region5.getBounds(), mRegion.getBounds()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "op", |
| args = {android.graphics.Region.class, android.graphics.Region.class, |
| android.graphics.Region.Op.class} |
| ) |
| public void testOp5() { |
| |
| Region region1 = new Region(); |
| Region region2 = new Region(0, 0, 20, 20); |
| Region region3 = new Region(5, 5, 10, 10); |
| Region region4 = new Region(10, 10, 30, 30); |
| Region region5 = new Region(40, 40, 60, 60); |
| |
| assertNullRegionOp5(region1); |
| assertDifferenceOp5(region1, region2, region3, region4, region5); |
| assertIntersectOp5(region1, region2, region3, region4, region5); |
| assertUnionOp5(region1, region2, region3, region4, region5); |
| assertXorOp5(region1, region2, region3, region4, region5); |
| assertReverseDifferenceOp5(region1, region2, region3, region4, region5); |
| assertReplaceOp5(region1, region2, region3, region4, region5); |
| } |
| |
| private void assertNullRegionOp5(Region region1) { |
| // Region without rectangle |
| mRegion = null; |
| mRegion = new Region(); |
| assertFalse(mRegion.op(mRegion, region1, Region.Op.DIFFERENCE)); |
| assertFalse(mRegion.op(mRegion, region1, Region.Op.INTERSECT)); |
| assertFalse(mRegion.op(mRegion, region1, Region.Op.UNION)); |
| assertFalse(mRegion.op(mRegion, region1, Region.Op.XOR)); |
| assertFalse(mRegion.op(mRegion, region1, Region.Op.REVERSE_DIFFERENCE)); |
| assertFalse(mRegion.op(mRegion, region1, Region.Op.REPLACE)); |
| } |
| |
| private void assertDifferenceOp5(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // DIFFERENCE, Region with rectangle |
| // subtract the op region from the first region |
| mRegion = null; |
| mRegion = new Region(); |
| // subtract null rectangle |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region1, Region.Op.DIFFERENCE)); |
| |
| // 1. subtract rectangle inside this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region3, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH1); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT1); |
| |
| // 2. subtract rectangle overlap this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region4, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT2); |
| |
| // 3. subtract rectangle out of this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region5, Region.Op.DIFFERENCE)); |
| assertPointsInsideRegion(DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertIntersectOp5(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // INTERSECT, Region with rectangle |
| // intersect the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // intersect null rectangle |
| mRegion.set(region1); |
| assertFalse(mRegion.op(region2, region1, Region.Op.INTERSECT)); |
| |
| // 1. intersect rectangle inside this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region3, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH1); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT1); |
| |
| // 2. intersect rectangle overlap this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region4, Region.Op.INTERSECT)); |
| assertPointsInsideRegion(INTERSECT_WITH2); |
| assertPointsOutsideRegion(INTERSECT_WITHOUT2); |
| |
| // 3. intersect rectangle out of this region |
| mRegion.set(region1); |
| assertFalse(mRegion.op(region2, region5, Region.Op.INTERSECT)); |
| } |
| |
| private void assertUnionOp5(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // UNION, Region with rectangle |
| // union (inclusive-or) the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // union null rectangle |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region1, Region.Op.UNION)); |
| assertTrue(mRegion.contains(6, 6)); |
| |
| // 1. union rectangle inside this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region3, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH1); |
| assertPointsOutsideRegion(UNION_WITHOUT1); |
| |
| // 2. union rectangle overlap this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region4, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH2); |
| assertPointsOutsideRegion(UNION_WITHOUT2); |
| |
| // 3. union rectangle out of this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region5, Region.Op.UNION)); |
| assertPointsInsideRegion(UNION_WITH3); |
| assertPointsOutsideRegion(UNION_WITHOUT3); |
| } |
| |
| private void assertXorOp5(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // XOR, Region with rectangle |
| // exclusive-or the two regions |
| mRegion = null; |
| mRegion = new Region(); |
| // xor null rectangle |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region1, Region.Op.XOR)); |
| |
| // 1. xor rectangle inside this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region3, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH1); |
| assertPointsOutsideRegion(XOR_WITHOUT1); |
| |
| // 2. xor rectangle overlap this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region4, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH2); |
| assertPointsOutsideRegion(XOR_WITHOUT2); |
| |
| // 3. xor rectangle out of this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region5, Region.Op.XOR)); |
| assertPointsInsideRegion(XOR_WITH3); |
| assertPointsOutsideRegion(XOR_WITHOUT3); |
| } |
| |
| private void assertReverseDifferenceOp5(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // REVERSE_DIFFERENCE, Region with rectangle |
| // reverse difference the first region from the op region |
| mRegion = null; |
| mRegion = new Region(); |
| // reverse difference null rectangle |
| mRegion.set(region1); |
| assertFalse(mRegion.op(region2, region1, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 1. reverse difference rectangle inside this region |
| mRegion.set(region1); |
| assertFalse(mRegion.op(region2, region3, Region.Op.REVERSE_DIFFERENCE)); |
| |
| // 2. reverse difference rectangle overlap this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region4, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH2); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT2); |
| |
| // 3. reverse difference rectangle out of this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region5, Region.Op.REVERSE_DIFFERENCE)); |
| assertPointsInsideRegion(REVERSE_DIFFERENCE_WITH3); |
| assertPointsOutsideRegion(REVERSE_DIFFERENCE_WITHOUT3); |
| } |
| |
| private void assertReplaceOp5(Region region1, Region region2, |
| Region region3, Region region4, Region region5) { |
| // REPLACE, Region with rectangle |
| // replace the dst region with the op region |
| mRegion = null; |
| mRegion = new Region(); |
| // subtract null rectangle |
| mRegion.set(region1); |
| assertFalse(mRegion.op(region2, region1, Region.Op.REPLACE)); |
| // subtract rectangle inside this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region3, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region3.getBounds(), mRegion.getBounds()); |
| // subtract rectangle overlap this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region4, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region4.getBounds(), mRegion.getBounds()); |
| // subtract rectangle out of this region |
| mRegion.set(region1); |
| assertTrue(mRegion.op(region2, region5, Region.Op.REPLACE)); |
| assertNotSame(region2.getBounds(), mRegion.getBounds()); |
| assertEquals(region5.getBounds(), mRegion.getBounds()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getBoundaryPath", |
| args = {} |
| ) |
| public void testGetBoundaryPath1() { |
| mRegion = new Region(); |
| assertTrue(mRegion.getBoundaryPath().isEmpty()); |
| |
| // Both clip and path are non-null. |
| Region clip = new Region(0, 0, 10, 10); |
| Path path = new Path(); |
| path.addRect(0, 0, 10, 10, Path.Direction.CW); |
| assertTrue(mRegion.setPath(path, clip)); |
| assertFalse(mRegion.getBoundaryPath().isEmpty()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "getBoundaryPath", |
| args = {android.graphics.Path.class} |
| ) |
| public void testGetBoundaryPath2() { |
| |
| mRegion = new Region(); |
| Path path = new Path(); |
| assertFalse(mRegion.getBoundaryPath(path)); |
| |
| // path is null |
| mRegion = new Region(0, 0, 10, 10); |
| path = new Path(); |
| assertTrue(mRegion.getBoundaryPath(path)); |
| |
| // region is null |
| mRegion = new Region(); |
| path = new Path(); |
| path.addRect(0, 0, 10, 10, Path.Direction.CW); |
| assertFalse(mRegion.getBoundaryPath(path)); |
| |
| // both path and region are non-null |
| mRegion = new Region(0, 0, 10, 10); |
| path = new Path(); |
| path.addRect(0, 0, 5, 5, Path.Direction.CW); |
| assertTrue(mRegion.getBoundaryPath(path)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "setPath", |
| args = {android.graphics.Path.class, android.graphics.Region.class} |
| ) |
| public void testSetPath() { |
| |
| mRegion = new Region(); |
| // Both clip and path are null. |
| Region clip = new Region(); |
| Path path = new Path(); |
| assertFalse(mRegion.setPath(path, clip)); |
| |
| // Only path is null. |
| path = new Path(); |
| clip = new Region(0, 0, 10, 10); |
| assertFalse(mRegion.setPath(path, clip)); |
| |
| // Only clip is null. |
| clip = new Region(); |
| path = new Path(); |
| path.addRect(0, 0, 10, 10, Path.Direction.CW); |
| assertFalse(mRegion.setPath(path, clip)); |
| |
| // Both clip and path are non-null. |
| clip = new Region(); |
| path = new Path(); |
| clip = new Region(0, 0, 10, 10); |
| path.addRect(0, 0, 10, 10, Path.Direction.CW); |
| assertTrue(mRegion.setPath(path, clip)); |
| |
| // Both clip and path are non-null. |
| path = new Path(); |
| clip = new Region(0, 0, 5, 5); |
| path.addRect(0, 0, 10, 10, Path.Direction.CW); |
| assertTrue(mRegion.setPath(path, clip)); |
| Rect expected = new Rect(0, 0, 5, 5); |
| Rect unexpected = new Rect(0, 0, 10, 10); |
| Rect actual = mRegion.getBounds(); |
| assertEquals(expected.right, actual.right); |
| assertNotSame(unexpected.right, actual.right); |
| |
| // Both clip and path are non-null. |
| path = new Path(); |
| clip = new Region(0, 0, 10, 10); |
| path.addRect(0, 0, 5, 5, Path.Direction.CW); |
| assertTrue(mRegion.setPath(path, clip)); |
| expected = new Rect(0, 0, 5, 5); |
| unexpected = new Rect(0, 0, 10, 10); |
| actual = mRegion.getBounds(); |
| assertEquals(expected.right, actual.right); |
| assertNotSame(unexpected.right, actual.right); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "translate", |
| args = {int.class, int.class} |
| ) |
| public void testTranslate1() { |
| |
| Rect rect1 = new Rect(0, 0, 20, 20); |
| Rect rect2 = new Rect(10, 10, 30, 30); |
| mRegion = new Region(0, 0, 20, 20); |
| mRegion.translate(10, 10); |
| assertNotSame(rect1, mRegion.getBounds()); |
| assertEquals(rect2, mRegion.getBounds()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "translate", |
| args = {int.class, int.class, android.graphics.Region.class} |
| ) |
| public void testTranslate2() { |
| |
| Region dst = new Region(); |
| Rect rect1 = new Rect(0, 0, 20, 20); |
| Rect rect2 = new Rect(10, 10, 30, 30); |
| mRegion = new Region(0, 0, 20, 20); |
| mRegion.translate(10, 10, dst); |
| assertEquals(rect1, mRegion.getBounds()); |
| assertNotSame(rect2, mRegion.getBounds()); |
| assertNotSame(rect1, dst.getBounds()); |
| assertEquals(rect2, dst.getBounds()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "writeToParcel", |
| args = {android.os.Parcel.class, int.class} |
| ) |
| public void testWriteToParcel() { |
| |
| int flags = 0; |
| Rect oriRect = new Rect(0, 0, 10, 10); |
| mRegion = new Region(); |
| |
| Parcel p = Parcel.obtain(); |
| mRegion.writeToParcel(p, flags); |
| assertEquals(8, p.dataSize()); |
| |
| p = Parcel.obtain(); |
| mRegion.set(oriRect); |
| mRegion.writeToParcel(p, flags); |
| assertEquals(24, p.dataSize()); |
| |
| p.setDataPosition(0); |
| Region dst = Region.CREATOR.createFromParcel(p); |
| assertEquals(oriRect.top, dst.getBounds().top); |
| assertEquals(oriRect.left, dst.getBounds().left); |
| assertEquals(oriRect.bottom, dst.getBounds().bottom); |
| assertEquals(oriRect.right, dst.getBounds().right); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "describeContents", |
| args = {} |
| ) |
| public void testDescribeContents() { |
| |
| mRegion = new Region(); |
| int actual = mRegion.describeContents(); |
| assertEquals(0, actual); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "quickReject", |
| args = {android.graphics.Rect.class} |
| ) |
| public void testQuickReject1() { |
| Rect oriRect = new Rect(0, 0, 20, 20); |
| Rect rect1 = new Rect(); |
| Rect rect2 = new Rect(40, 40, 60, 60); |
| Rect rect3 = new Rect(0, 0, 10, 10); |
| Rect rect4 = new Rect(10, 10, 30, 30); |
| |
| mRegion = new Region(); |
| // Return true if the region is empty |
| assertTrue(mRegion.quickReject(rect1)); |
| mRegion.set(oriRect); |
| assertTrue(mRegion.quickReject(rect2)); |
| mRegion.set(oriRect); |
| assertFalse(mRegion.quickReject(rect3)); |
| mRegion.set(oriRect); |
| assertFalse(mRegion.quickReject(rect4)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "quickReject", |
| args = {int.class, int.class, int.class, int.class} |
| ) |
| public void testQuickReject2() { |
| mRegion = new Region(); |
| // Return true if the region is empty |
| assertTrue(mRegion.quickReject(0, 0, 0, 0)); |
| mRegion.set(0, 0, 20, 20); |
| assertTrue(mRegion.quickReject(40, 40, 60, 60)); |
| mRegion.set(0, 0, 20, 20); |
| assertFalse(mRegion.quickReject(0, 0, 10, 10)); |
| mRegion.set(0, 0, 20, 20); |
| assertFalse(mRegion.quickReject(10, 10, 30, 30)); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| method = "quickReject", |
| args = {android.graphics.Region.class} |
| ) |
| public void testQuickReject3() { |
| Region oriRegion = new Region(0, 0, 20, 20); |
| Region region1 = new Region(); |
| Region region2 = new Region(40, 40, 60, 60); |
| Region region3 = new Region(0, 0, 10, 10); |
| Region region4 = new Region(10, 10, 30, 30); |
| |
| mRegion = new Region(); |
| // Return true if the region is empty |
| assertTrue(mRegion.quickReject(region1)); |
| mRegion.set(oriRegion); |
| assertTrue(mRegion.quickReject(region2)); |
| mRegion.set(oriRegion); |
| assertFalse(mRegion.quickReject(region3)); |
| mRegion.set(oriRegion); |
| assertFalse(mRegion.quickReject(region4)); |
| } |
| |
| } |
