tests/tests/graphics/src/android/graphics/cts/PathTest.java - platform/cts - Git at Google

 /*
  * 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 static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;

 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.graphics.Path;
 import android.graphics.RectF;

 import androidx.test.filters.SmallTest;
 import androidx.test.runner.AndroidJUnit4;

 import org.junit.Test;
 import org.junit.runner.RunWith;

 @SmallTest
 @RunWith(AndroidJUnit4.class)
 public class PathTest {

     // Test constants
     private static final float LEFT = 10.0f;
     private static final float RIGHT = 50.0f;
     private static final float TOP = 10.0f;
     private static final float BOTTOM = 50.0f;
     private static final float XCOORD = 40.0f;
     private static final float YCOORD = 40.0f;

     @Test
     public void testConstructor() {
         // new the Path instance
         new Path();

         // another the Path instance with different params
         new Path(new Path());
     }

     @Test
     public void testAddRect1() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.addRect(rect, Path.Direction.CW);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testAddRect2() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.addRect(LEFT, TOP, RIGHT, BOTTOM, Path.Direction.CW);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testMoveTo() {
         Path path = new Path();
         path.moveTo(10.0f, 10.0f);
     }

     @Test
     public void testSet() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         Path path1 = new Path();
         addRectToPath(path1);
         path.set(path1);
         verifyPathsAreEquivalent(path, path1);
     }

     @Test
     public void testSetCleanOld() {
         Path path = new Path();
         addRectToPath(path);
         path.addRect(new RectF(0, 0, 10, 10), Path.Direction.CW);
         Path path1 = new Path();
         path1.addRect(new RectF(10, 10, 20, 20), Path.Direction.CW);
         path.set(path1);
         verifyPathsAreEquivalent(path, path1);
     }

     @Test
     public void testSetEmptyPath() {
         Path path = new Path();
         addRectToPath(path);
         Path path1 = new Path();
         path.set(path1);
         verifyPathsAreEquivalent(path, path1);
     }

     @Test
     public void testAccessFillType() {
         // set the expected value
         Path.FillType expected1 = Path.FillType.EVEN_ODD;
         Path.FillType expected2 = Path.FillType.INVERSE_EVEN_ODD;
         Path.FillType expected3 = Path.FillType.INVERSE_WINDING;
         Path.FillType expected4 = Path.FillType.WINDING;

         // new the Path instance
         Path path = new Path();
         // set FillType by {@link Path#setFillType(FillType)}
         path.setFillType(Path.FillType.EVEN_ODD);
         assertEquals(expected1, path.getFillType());
         path.setFillType(Path.FillType.INVERSE_EVEN_ODD);
         assertEquals(expected2, path.getFillType());
         path.setFillType(Path.FillType.INVERSE_WINDING);
         assertEquals(expected3, path.getFillType());
         path.setFillType(Path.FillType.WINDING);
         assertEquals(expected4, path.getFillType());
     }

     @Test
     public void testRQuadTo() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.rQuadTo(5.0f, 5.0f, 10.0f, 10.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testTransform1() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         Path dst = new Path();
         addRectToPath(path);
         path.transform(new Matrix(), dst);
         assertFalse(dst.isEmpty());
     }

     @Test
     public void testLineTo() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.lineTo(XCOORD, YCOORD);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testClose() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         addRectToPath(path);
         path.close();
     }

     @Test
     public void testQuadTo() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.quadTo(20.0f, 20.0f, 40.0f, 40.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testAddCircle() {
         // new the Path instance
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.addCircle(XCOORD, YCOORD, 10.0f, Path.Direction.CW);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testArcTo1() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.arcTo(oval, 0.0f, 30.0f, true);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testArcTo2() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.arcTo(oval, 0.0f, 30.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testComputeBounds1() {
         RectF expected = new RectF(0.0f, 0.0f, 0.0f, 0.0f);
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF bounds = new RectF();
         path.computeBounds(bounds, true);
         assertEquals(expected.width(), bounds.width(), 0.0f);
         assertEquals(expected.height(), bounds.height(), 0.0f);
         path.computeBounds(bounds, false);
         assertEquals(expected.width(), bounds.width(), 0.0f);
         assertEquals(expected.height(), bounds.height(), 0.0f);
     }

     @Test
     public void testComputeBounds2() {
         RectF expected = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF bounds = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.addRect(bounds, Path.Direction.CW);
         path.computeBounds(bounds, true);
         assertEquals(expected.width(), bounds.width(), 0.0f);
         assertEquals(expected.height(), bounds.height(), 0.0f);
         path.computeBounds(bounds, false);
         assertEquals(expected.width(), bounds.width(), 0.0f);
         assertEquals(expected.height(), bounds.height(), 0.0f);
     }

     @Test
     public void testSetLastPoint() {
         Path path = new Path();
         path.setLastPoint(10.0f, 10.0f);
     }

     @Test
     public void testRLineTo() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.rLineTo(10.0f, 10.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testIsEmpty() {

         Path path = new Path();
         assertTrue(path.isEmpty());
         addRectToPath(path);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testRewind() {
         Path.FillType expected = Path.FillType.EVEN_ODD;

         Path path = new Path();
         assertTrue(path.isEmpty());
         addRectToPath(path);
         path.rewind();
         path.setFillType(Path.FillType.EVEN_ODD);
         assertTrue(path.isEmpty());
         assertEquals(expected, path.getFillType());
     }

     @Test
     public void testAddOval() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.addOval(oval, Path.Direction.CW);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testIsRect() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         addRectToPath(path);
     }

     @Test
     public void testAddPath1() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         Path src = new Path();
         addRectToPath(src);
         path.addPath(src, 10.0f, 10.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testAddPath2() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         Path src = new Path();
         addRectToPath(src);
         path.addPath(src);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testAddPath3() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         Path src = new Path();
         addRectToPath(src);
         Matrix matrix = new Matrix();
         path.addPath(src, matrix);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testAddRoundRect1() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.addRoundRect(rect, XCOORD, YCOORD, Path.Direction.CW);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testAddRoundRect2() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         float[] radii = new float[8];
         for (int i = 0; i < 8; i++) {
             radii[i] = 10.0f + i * 5.0f;
         }
         path.addRoundRect(rect, radii, Path.Direction.CW);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testIsConvex1() {
         Path path = new Path();
         path.addRect(0, 0, 100, 10, Path.Direction.CW);
         assertTrue(path.isConvex());

         path.addRect(0, 0, 10, 100, Path.Direction.CW);
         assertFalse(path.isConvex()); // path is concave
     }

     @Test
     public void testIsConvex2() {
         Path path = new Path();
         path.addRect(0, 0, 40, 40, Path.Direction.CW);
         assertTrue(path.isConvex());

         path.addRect(10, 10, 30, 30, Path.Direction.CCW);
         assertFalse(path.isConvex()); // path has hole, isn't convex
     }

     @Test
     public void testIsConvex3() {
         Path path = new Path();
         path.addRect(0, 0, 10, 10, Path.Direction.CW);
         assertTrue(path.isConvex());

         path.addRect(0, 20, 10, 10, Path.Direction.CW);
         assertFalse(path.isConvex()); // path isn't one convex shape
     }

     @Test
     public void testIsInverseFillType() {
         Path path = new Path();
         assertFalse(path.isInverseFillType());
         path.setFillType(Path.FillType.INVERSE_EVEN_ODD);
         assertTrue(path.isInverseFillType());
     }

     @Test
     public void testOffset1() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         addRectToPath(path);
         Path dst = new Path();
         path.offset(XCOORD, YCOORD, dst);
         assertFalse(dst.isEmpty());
     }

     @Test
     public void testCubicTo() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.cubicTo(10.0f, 10.0f, 20.0f, 20.0f, 30.0f, 30.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testReset() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         Path path1 = new Path();
         addRectToPath(path1);
         path.set(path1);
         assertFalse(path.isEmpty());
         path.reset();
         assertTrue(path.isEmpty());
     }

     @Test
     public void testToggleInverseFillType() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.toggleInverseFillType();
         assertTrue(path.isInverseFillType());
     }

     @Test
     public void testAddArc() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.addArc(oval, 0.0f, 30.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testRCubicTo() {
         Path path = new Path();
         assertTrue(path.isEmpty());
         path.rCubicTo(10.0f, 10.0f, 11.0f, 11.0f, 12.0f, 12.0f);
         assertFalse(path.isEmpty());
     }

     @Test
     public void testOffsetTextPath() {
         Paint paint = new Paint();
         Path path = new Path();
         paint.setTextSize(20);
         String text = "abc";
         paint.getTextPath(text, 0, text.length() - 1, 0, 0, path);
         RectF expectedRect = new RectF();
         path.computeBounds(expectedRect, false);
         assertFalse(expectedRect.isEmpty());
         int offset = 10;
         expectedRect.offset(offset, offset);

         path.offset(offset, offset);
         RectF offsettedRect = new RectF();
         path.computeBounds(offsettedRect, false);
         assertEquals(expectedRect, offsettedRect);
     }

     @Test(expected=IllegalArgumentException.class)
     public void testApproximate_lowError() {
         new Path().approximate(-0.1f);
     }

     @Test
     public void testApproximate_rect_cw() {
         Path path = new Path();
         path.addRect(0, 0, 100, 100, Path.Direction.CW);
         assertArrayEquals(new float[] {
                 0, 0, 0,
                 0.25f, 100, 0,
                 0.50f, 100, 100,
                 0.75f, 0, 100,
                 1, 0, 0,
         }, path.approximate(1f), 0);
     }

     @Test
     public void testApproximate_rect_ccw() {
         Path path = new Path();
         path.addRect(0, 0, 100, 100, Path.Direction.CCW);
         assertArrayEquals(new float[] {
                 0, 0, 0,
                 0.25f, 0, 100,
                 0.50f, 100, 100,
                 0.75f, 100, 0,
                 1, 0, 0,
         }, path.approximate(1f), 0);
     }

     @Test
     public void testApproximate_empty() {
         Path path = new Path();
         assertArrayEquals(new float[] {
                 0, 0, 0,
                 1, 0, 0,
         }, path.approximate(0.5f), 0);
     }

     @Test
     public void testApproximate_circle() {
         Path path = new Path();
         path.addCircle(0, 0, 50, Path.Direction.CW);
         assertTrue(path.approximate(0.25f).length > 20);
     }

     /** This test just ensures the process doesn't crash. The actual output is not interesting
      *  hence the lack of asserts, as the only behavior that's being asserted is that it
      *  doesn't crash.
      */
     @Test
     public void testUseAfterFinalize() throws Throwable {
         PathAbuser pathAbuser = new PathAbuser();

         // Basic test that we created a path successfully
         assertTrue(pathAbuser.isEmpty());
         addRectToPath(pathAbuser);
         assertTrue(pathAbuser.isRect(null));
         assertFalse(pathAbuser.isEmpty());

         // Now use-after-finalize.
         pathAbuser.destroy();
         pathAbuser.isEmpty();
         pathAbuser.isRect(null);
         pathAbuser.destroy();
         pathAbuser.isEmpty();
         pathAbuser.isRect(null);
         pathAbuser.destroy();
     }

     private static final class PathAbuser extends Path {
         public void destroy() throws Throwable {
             finalize();
         }
     }

     private static void verifyPathsAreEquivalent(Path actual, Path expected) {
         Bitmap actualBitmap = drawAndGetBitmap(actual);
         Bitmap expectedBitmap = drawAndGetBitmap(expected);
         assertTrue(actualBitmap.sameAs(expectedBitmap));
     }

     private static final int WIDTH = 100;
     private static final int HEIGHT = 100;

     private static Bitmap drawAndGetBitmap(Path path) {
         Bitmap bitmap = Bitmap.createBitmap(WIDTH, HEIGHT, Bitmap.Config.ARGB_8888);
         bitmap.eraseColor(Color.BLACK);
         Paint paint = new Paint();
         paint.setColor(Color.RED);
         Canvas canvas = new Canvas(bitmap);
         canvas.drawPath(path, paint);
         return bitmap;
     }

     private void addRectToPath(Path path) {
         RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
         path.addRect(rect, Path.Direction.CW);
     }
 }
	/*
	* 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 static org.junit.Assert.assertArrayEquals;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertTrue;

	import android.graphics.Bitmap;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Matrix;
	import android.graphics.Paint;
	import android.graphics.Path;
	import android.graphics.RectF;

	import androidx.test.filters.SmallTest;
	import androidx.test.runner.AndroidJUnit4;

	import org.junit.Test;
	import org.junit.runner.RunWith;

	@SmallTest
	@RunWith(AndroidJUnit4.class)
	public class PathTest {

	// Test constants
	private static final float LEFT = 10.0f;
	private static final float RIGHT = 50.0f;
	private static final float TOP = 10.0f;
	private static final float BOTTOM = 50.0f;
	private static final float XCOORD = 40.0f;
	private static final float YCOORD = 40.0f;

	@Test
	public void testConstructor() {
	// new the Path instance
	new Path();

	// another the Path instance with different params
	new Path(new Path());
	}

	@Test
	public void testAddRect1() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.addRect(rect, Path.Direction.CW);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testAddRect2() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.addRect(LEFT, TOP, RIGHT, BOTTOM, Path.Direction.CW);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testMoveTo() {
	Path path = new Path();
	path.moveTo(10.0f, 10.0f);
	}

	@Test
	public void testSet() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	Path path1 = new Path();
	addRectToPath(path1);
	path.set(path1);
	verifyPathsAreEquivalent(path, path1);
	}

	@Test
	public void testSetCleanOld() {
	Path path = new Path();
	addRectToPath(path);
	path.addRect(new RectF(0, 0, 10, 10), Path.Direction.CW);
	Path path1 = new Path();
	path1.addRect(new RectF(10, 10, 20, 20), Path.Direction.CW);
	path.set(path1);
	verifyPathsAreEquivalent(path, path1);
	}

	@Test
	public void testSetEmptyPath() {
	Path path = new Path();
	addRectToPath(path);
	Path path1 = new Path();
	path.set(path1);
	verifyPathsAreEquivalent(path, path1);
	}

	@Test
	public void testAccessFillType() {
	// set the expected value
	Path.FillType expected1 = Path.FillType.EVEN_ODD;
	Path.FillType expected2 = Path.FillType.INVERSE_EVEN_ODD;
	Path.FillType expected3 = Path.FillType.INVERSE_WINDING;
	Path.FillType expected4 = Path.FillType.WINDING;

	// new the Path instance
	Path path = new Path();
	// set FillType by {@link Path#setFillType(FillType)}
	path.setFillType(Path.FillType.EVEN_ODD);
	assertEquals(expected1, path.getFillType());
	path.setFillType(Path.FillType.INVERSE_EVEN_ODD);
	assertEquals(expected2, path.getFillType());
	path.setFillType(Path.FillType.INVERSE_WINDING);
	assertEquals(expected3, path.getFillType());
	path.setFillType(Path.FillType.WINDING);
	assertEquals(expected4, path.getFillType());
	}

	@Test
	public void testRQuadTo() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.rQuadTo(5.0f, 5.0f, 10.0f, 10.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testTransform1() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	Path dst = new Path();
	addRectToPath(path);
	path.transform(new Matrix(), dst);
	assertFalse(dst.isEmpty());
	}

	@Test
	public void testLineTo() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.lineTo(XCOORD, YCOORD);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testClose() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	addRectToPath(path);
	path.close();
	}

	@Test
	public void testQuadTo() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.quadTo(20.0f, 20.0f, 40.0f, 40.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testAddCircle() {
	// new the Path instance
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.addCircle(XCOORD, YCOORD, 10.0f, Path.Direction.CW);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testArcTo1() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.arcTo(oval, 0.0f, 30.0f, true);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testArcTo2() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.arcTo(oval, 0.0f, 30.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testComputeBounds1() {
	RectF expected = new RectF(0.0f, 0.0f, 0.0f, 0.0f);
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF bounds = new RectF();
	path.computeBounds(bounds, true);
	assertEquals(expected.width(), bounds.width(), 0.0f);
	assertEquals(expected.height(), bounds.height(), 0.0f);
	path.computeBounds(bounds, false);
	assertEquals(expected.width(), bounds.width(), 0.0f);
	assertEquals(expected.height(), bounds.height(), 0.0f);
	}

	@Test
	public void testComputeBounds2() {
	RectF expected = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF bounds = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.addRect(bounds, Path.Direction.CW);
	path.computeBounds(bounds, true);
	assertEquals(expected.width(), bounds.width(), 0.0f);
	assertEquals(expected.height(), bounds.height(), 0.0f);
	path.computeBounds(bounds, false);
	assertEquals(expected.width(), bounds.width(), 0.0f);
	assertEquals(expected.height(), bounds.height(), 0.0f);
	}

	@Test
	public void testSetLastPoint() {
	Path path = new Path();
	path.setLastPoint(10.0f, 10.0f);
	}

	@Test
	public void testRLineTo() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.rLineTo(10.0f, 10.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testIsEmpty() {

	Path path = new Path();
	assertTrue(path.isEmpty());
	addRectToPath(path);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testRewind() {
	Path.FillType expected = Path.FillType.EVEN_ODD;

	Path path = new Path();
	assertTrue(path.isEmpty());
	addRectToPath(path);
	path.rewind();
	path.setFillType(Path.FillType.EVEN_ODD);
	assertTrue(path.isEmpty());
	assertEquals(expected, path.getFillType());
	}

	@Test
	public void testAddOval() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.addOval(oval, Path.Direction.CW);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testIsRect() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	addRectToPath(path);
	}

	@Test
	public void testAddPath1() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	Path src = new Path();
	addRectToPath(src);
	path.addPath(src, 10.0f, 10.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testAddPath2() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	Path src = new Path();
	addRectToPath(src);
	path.addPath(src);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testAddPath3() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	Path src = new Path();
	addRectToPath(src);
	Matrix matrix = new Matrix();
	path.addPath(src, matrix);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testAddRoundRect1() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.addRoundRect(rect, XCOORD, YCOORD, Path.Direction.CW);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testAddRoundRect2() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	float[] radii = new float[8];
	for (int i = 0; i < 8; i++) {
	radii[i] = 10.0f + i * 5.0f;
	}
	path.addRoundRect(rect, radii, Path.Direction.CW);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testIsConvex1() {
	Path path = new Path();
	path.addRect(0, 0, 100, 10, Path.Direction.CW);
	assertTrue(path.isConvex());

	path.addRect(0, 0, 10, 100, Path.Direction.CW);
	assertFalse(path.isConvex()); // path is concave
	}

	@Test
	public void testIsConvex2() {
	Path path = new Path();
	path.addRect(0, 0, 40, 40, Path.Direction.CW);
	assertTrue(path.isConvex());

	path.addRect(10, 10, 30, 30, Path.Direction.CCW);
	assertFalse(path.isConvex()); // path has hole, isn't convex
	}

	@Test
	public void testIsConvex3() {
	Path path = new Path();
	path.addRect(0, 0, 10, 10, Path.Direction.CW);
	assertTrue(path.isConvex());

	path.addRect(0, 20, 10, 10, Path.Direction.CW);
	assertFalse(path.isConvex()); // path isn't one convex shape
	}

	@Test
	public void testIsInverseFillType() {
	Path path = new Path();
	assertFalse(path.isInverseFillType());
	path.setFillType(Path.FillType.INVERSE_EVEN_ODD);
	assertTrue(path.isInverseFillType());
	}

	@Test
	public void testOffset1() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	addRectToPath(path);
	Path dst = new Path();
	path.offset(XCOORD, YCOORD, dst);
	assertFalse(dst.isEmpty());
	}

	@Test
	public void testCubicTo() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.cubicTo(10.0f, 10.0f, 20.0f, 20.0f, 30.0f, 30.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testReset() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	Path path1 = new Path();
	addRectToPath(path1);
	path.set(path1);
	assertFalse(path.isEmpty());
	path.reset();
	assertTrue(path.isEmpty());
	}

	@Test
	public void testToggleInverseFillType() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.toggleInverseFillType();
	assertTrue(path.isInverseFillType());
	}

	@Test
	public void testAddArc() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	RectF oval = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.addArc(oval, 0.0f, 30.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testRCubicTo() {
	Path path = new Path();
	assertTrue(path.isEmpty());
	path.rCubicTo(10.0f, 10.0f, 11.0f, 11.0f, 12.0f, 12.0f);
	assertFalse(path.isEmpty());
	}

	@Test
	public void testOffsetTextPath() {
	Paint paint = new Paint();
	Path path = new Path();
	paint.setTextSize(20);
	String text = "abc";
	paint.getTextPath(text, 0, text.length() - 1, 0, 0, path);
	RectF expectedRect = new RectF();
	path.computeBounds(expectedRect, false);
	assertFalse(expectedRect.isEmpty());
	int offset = 10;
	expectedRect.offset(offset, offset);

	path.offset(offset, offset);
	RectF offsettedRect = new RectF();
	path.computeBounds(offsettedRect, false);
	assertEquals(expectedRect, offsettedRect);
	}

	@Test(expected=IllegalArgumentException.class)
	public void testApproximate_lowError() {
	new Path().approximate(-0.1f);
	}

	@Test
	public void testApproximate_rect_cw() {
	Path path = new Path();
	path.addRect(0, 0, 100, 100, Path.Direction.CW);
	assertArrayEquals(new float[] {
	0, 0, 0,
	0.25f, 100, 0,
	0.50f, 100, 100,
	0.75f, 0, 100,
	1, 0, 0,
	}, path.approximate(1f), 0);
	}

	@Test
	public void testApproximate_rect_ccw() {
	Path path = new Path();
	path.addRect(0, 0, 100, 100, Path.Direction.CCW);
	assertArrayEquals(new float[] {
	0, 0, 0,
	0.25f, 0, 100,
	0.50f, 100, 100,
	0.75f, 100, 0,
	1, 0, 0,
	}, path.approximate(1f), 0);
	}

	@Test
	public void testApproximate_empty() {
	Path path = new Path();
	assertArrayEquals(new float[] {
	0, 0, 0,
	1, 0, 0,
	}, path.approximate(0.5f), 0);
	}

	@Test
	public void testApproximate_circle() {
	Path path = new Path();
	path.addCircle(0, 0, 50, Path.Direction.CW);
	assertTrue(path.approximate(0.25f).length > 20);
	}

	/** This test just ensures the process doesn't crash. The actual output is not interesting
	* hence the lack of asserts, as the only behavior that's being asserted is that it
	* doesn't crash.
	*/
	@Test
	public void testUseAfterFinalize() throws Throwable {
	PathAbuser pathAbuser = new PathAbuser();

	// Basic test that we created a path successfully
	assertTrue(pathAbuser.isEmpty());
	addRectToPath(pathAbuser);
	assertTrue(pathAbuser.isRect(null));
	assertFalse(pathAbuser.isEmpty());

	// Now use-after-finalize.
	pathAbuser.destroy();
	pathAbuser.isEmpty();
	pathAbuser.isRect(null);
	pathAbuser.destroy();
	pathAbuser.isEmpty();
	pathAbuser.isRect(null);
	pathAbuser.destroy();
	}

	private static final class PathAbuser extends Path {
	public void destroy() throws Throwable {
	finalize();
	}
	}

	private static void verifyPathsAreEquivalent(Path actual, Path expected) {
	Bitmap actualBitmap = drawAndGetBitmap(actual);
	Bitmap expectedBitmap = drawAndGetBitmap(expected);
	assertTrue(actualBitmap.sameAs(expectedBitmap));
	}

	private static final int WIDTH = 100;
	private static final int HEIGHT = 100;

	private static Bitmap drawAndGetBitmap(Path path) {
	Bitmap bitmap = Bitmap.createBitmap(WIDTH, HEIGHT, Bitmap.Config.ARGB_8888);
	bitmap.eraseColor(Color.BLACK);
	Paint paint = new Paint();
	paint.setColor(Color.RED);
	Canvas canvas = new Canvas(bitmap);
	canvas.drawPath(path, paint);
	return bitmap;
	}

	private void addRectToPath(Path path) {
	RectF rect = new RectF(LEFT, TOP, RIGHT, BOTTOM);
	path.addRect(rect, Path.Direction.CW);
	}
	}