2 files changed, 390 insertions, 0 deletions
diff --git a/org.jacoco.core.test/src-java7/org/jacoco/core/test/filter/TryWithResourcesTest.java b/org.jacoco.core.test/src-java7/org/jacoco/core/test/filter/TryWithResourcesTest.java
new file mode 100644
index 00000000..1530505c
--- /dev/null
+++ b/org.jacoco.core.test/src-java7/org/jacoco/core/test/filter/TryWithResourcesTest.java
@@ -0,0 +1,186 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 Mountainminds GmbH & Co. KG and Contributors
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Evgeny Mandrikov - initial API and implementation
+ *
+ *******************************************************************************/
+package org.jacoco.core.test.filter;
+
+import org.jacoco.core.analysis.ICounter;
+import org.jacoco.core.test.filter.targets.TryWithResources;
+import org.jacoco.core.test.validation.ValidationTestBase;
+import org.junit.Test;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Test of filtering of a bytecode that is generated for a try-with-resources
+ * statement.
+ */
+public class TryWithResourcesTest extends ValidationTestBase {
+
+	public TryWithResourcesTest() {
+		super("src-java7", TryWithResources.class);
+	}
+
+	/**
+	 * {@link TryWithResources#test()}
+	 */
+	@Test
+	public void test() {
+		assertLine("test.before", ICounter.FULLY_COVERED);
+		// without filter next line covered partly:
+		assertLine("test.try", ICounter.FULLY_COVERED);
+		assertLine("test.open1", ICounter.FULLY_COVERED);
+		assertLine("test.open2", ICounter.FULLY_COVERED);
+		assertLine("test.open3", ICounter.FULLY_COVERED);
+		assertLine("test.body", ICounter.FULLY_COVERED);
+		// without filter next line has branches:
+		assertLine("test.close", ICounter.EMPTY);
+		assertLine("test.catch", ICounter.NOT_COVERED);
+		assertLine("test.finally", ICounter.PARTLY_COVERED);
+	}
+
+	/**
+	 * {@link TryWithResources#test2()}
+	 */
+	@Test
+	public void test2() {
+		assertLine("test2.before", ICounter.FULLY_COVERED);
+		// without filter next line covered partly:
+		assertLine("test2.try", ICounter.FULLY_COVERED);
+		assertLine("test2.open1", ICounter.FULLY_COVERED);
+		assertLine("test2.open2", ICounter.FULLY_COVERED);
+		assertLine("test2.open3", ICounter.FULLY_COVERED);
+		assertLine("test2.body", ICounter.FULLY_COVERED);
+		// without filter next line has branches:
+		assertLine("test2.close", ICounter.EMPTY);
+		assertLine("test2.catch", ICounter.NOT_COVERED);
+		assertLine("test2.finally", ICounter.PARTLY_COVERED);
+		assertLine("test2.after", ICounter.FULLY_COVERED);
+	}
+
+	/**
+	 * {@link TryWithResources#returnInBody()}
+	 */
+	@Test
+	public void returnInBody() {
+		// without filter next line covered partly:
+		assertLine("returnInBody.try", ICounter.FULLY_COVERED);
+		assertLine("returnInBody.open", ICounter.FULLY_COVERED);
+
+		// without filter next line has branches:
+		if (isJDKCompiler) {
+			// https://bugs.openjdk.java.net/browse/JDK-8134759
+			// javac 7 and 8 up to 8u92 are affected
+			final String jdkVersion = System.getProperty("java.version");
+			final Matcher m = Pattern.compile("1\\.8\\.0_(\\d++)(-ea)?")
+					.matcher(jdkVersion);
+			if (jdkVersion.startsWith("1.7.0_")
+					|| (m.matches() && Integer.parseInt(m.group(1)) < 92)) {
+				assertLine("returnInBody.close", ICounter.FULLY_COVERED, 0, 0);
+			} else {
+				assertLine("returnInBody.close", ICounter.EMPTY);
+			}
+		} else {
+			assertLine("returnInBody.close", ICounter.EMPTY);
+		}
+
+		assertLine("returnInBody.return", ICounter.FULLY_COVERED);
+	}
+
+	/**
+	 * {@link TryWithResources#nested()}
+	 */
+	@Test
+	public void nested() {
+		// without filter next line covered partly:
+		assertLine("nested.try1", ICounter.FULLY_COVERED);
+		assertLine("nested.open1", ICounter.FULLY_COVERED);
+		assertLine("nested.catch1", ICounter.NOT_COVERED);
+
+		// without filter next line covered partly:
+		assertLine("nested.try2", ICounter.FULLY_COVERED);
+		assertLine("nested.body", ICounter.FULLY_COVERED);
+		assertLine("nested.catch2", ICounter.NOT_COVERED);
+		assertLine("nested.finally2", ICounter.PARTLY_COVERED);
+
+		// next lines not covered on exceptional path:
+		assertLine("nested.try3", ICounter.PARTLY_COVERED, 0, 0);
+		assertLine("nested.open3", ICounter.PARTLY_COVERED, 0, 0);
+		assertLine("nested.body3", ICounter.PARTLY_COVERED, 0, 0);
+		assertLine("nested.catch3", ICounter.NOT_COVERED);
+		assertLine("nested.finally3", ICounter.PARTLY_COVERED, 0, 0);
+
+		// without filter next lines have branches:
+		assertLine("nested.close3", ICounter.EMPTY);
+		assertLine("nested.close2", ICounter.EMPTY);
+		assertLine("nested.close1", ICounter.EMPTY);
+	}
+
+	/**
+	 * {@link TryWithResources#returnInCatch()}
+	 */
+	@Test
+	public void returnInCatch() {
+		// without filter next line covered partly:
+		assertLine("returnInCatch.try1", ICounter.FULLY_COVERED);
+		assertLine("returnInCatch.open", ICounter.FULLY_COVERED);
+		assertLine("returnInCatch.finally1", ICounter.PARTLY_COVERED, 5, 1);
+		// without filter next line has branches:
+		assertLine("returnInCatch.close", ICounter.EMPTY);
+
+		assertLine("returnInCatch.try2", ICounter.EMPTY);
+		assertLine("returnInCatch.finally2", ICounter.PARTLY_COVERED, 5, 1);
+	}
+
+	/*
+	 * Corner cases
+	 */
+
+	/**
+	 * {@link TryWithResources#handwritten()}
+	 */
+	@Test
+	public void handwritten() {
+		if (isJDKCompiler) {
+			assertLine("handwritten", /* partly when ECJ: */ICounter.EMPTY);
+		}
+	}
+
+	/**
+	 * {@link TryWithResources#empty()}
+	 */
+	@Test
+	public void empty() {
+		assertLine("empty.try", ICounter.FULLY_COVERED, 0, 0);
+		assertLine("empty.open", ICounter.FULLY_COVERED);
+		// empty when EJC:
+		if (isJDKCompiler) {
+			final String jdkVersion = System.getProperty("java.version");
+			if (jdkVersion.startsWith("9-")) {
+				assertLine("empty.close", ICounter.FULLY_COVERED, 0, 0);
+			} else {
+				// branches with javac 7 and 8
+				assertLine("empty.close", ICounter.PARTLY_COVERED);
+			}
+		}
+	}
+
+	/**
+	 * {@link TryWithResources#throwInBody()}
+	 */
+	@Test
+	public void throwInBody() {
+		// not filtered
+		assertLine("throwInBody.try", ICounter.NOT_COVERED);
+		assertLine("throwInBody.close", ICounter.NOT_COVERED);
+	}
+
+}
diff --git a/org.jacoco.core.test/src-java7/org/jacoco/core/test/filter/targets/TryWithResources.java b/org.jacoco.core.test/src-java7/org/jacoco/core/test/filter/targets/TryWithResources.java
new file mode 100644
index 00000000..19a4651d
--- /dev/null
+++ b/org.jacoco.core.test/src-java7/org/jacoco/core/test/filter/targets/TryWithResources.java
@@ -0,0 +1,204 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2017 Mountainminds GmbH & Co. KG and Contributors
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *    Evgeny Mandrikov - initial API and implementation
+ *
+ *******************************************************************************/
+package org.jacoco.core.test.filter.targets;
+
+import static org.jacoco.core.test.validation.targets.Stubs.f;
+import static org.jacoco.core.test.validation.targets.Stubs.nop;
+
+import java.io.Closeable;
+import java.io.IOException;
+
+/**
+ * This test target is a try-with-resources statement.
+ */
+public class TryWithResources {
+
+	private static class Resource implements Closeable {
+		@Override
+		public void close() {
+		}
+	}
+
+	/**
+	 * Closing performed using {@link org.objectweb.asm.Opcodes#INVOKEVIRTUAL}
+	 * or {@link org.objectweb.asm.Opcodes#INVOKEINTERFACE} depending on a class
+	 * of resource.
+	 */
+	private static Object test() throws Exception {
+		nop(); // $line-test.before$
+		try ( // $line-test.try$
+				Resource r1 = new Resource(); // $line-test.open1$
+				Closeable r2 = new Resource(); // $line-test.open2$
+				AutoCloseable r3 = new Resource() // $line-test.open3$
+		) {
+			return read(r1, r2, r3); // $line-test.body$
+		} // $line-test.close$
+		catch (Exception e) {
+			nop(); // $line-test.catch$
+			throw e;
+		} finally {
+			nop(); // $line-test.finally$
+		}
+	}
+
+	private static void test2() throws Exception {
+		nop(); // $line-test2.before$
+		try ( // $line-test2.try$
+				Resource r1 = new Resource(); // $line-test2.open1$
+				Closeable r2 = new Resource(); // $line-test2.open2$
+				AutoCloseable r3 = new Resource() // $line-test2.open3$
+		) {
+			read(r1, r2, r3); // $line-test2.body$
+		} // $line-test2.close$
+		catch (Exception e) {
+			nop(); // $line-test2.catch$
+		} finally {
+			nop(); // $line-test2.finally$
+		}
+		nop(); // $line-test2.after$
+	}
+
+	private static Object returnInBody() throws IOException {
+		try ( // $line-returnInBody.try$
+				Closeable r = new Resource() // $line-returnInBody.open$
+		) {
+			return read(r); // $line-returnInBody.return$
+		} // $line-returnInBody.close$
+	}
+
+	private static void nested() {
+		try ( // $line-nested.try1$
+				Resource r1 = new Resource() // $line-nested.open1$
+		) {
+
+			try ( // $line-nested.try2$
+					Resource r2 = new Resource() // $line-nested.open2$
+			) {
+				nop(r1.toString() + r2.toString()); // $line-nested.body$
+			} // $line-nested.close2$
+			catch (Exception e) {
+				nop(); // $line-nested.catch2$
+			} finally {
+				nop(); // $line-nested.finally2$
+			}
+
+		} // $line-nested.close1$
+		catch (Exception e) {
+			nop(); // $line-nested.catch1$
+		} finally {
+
+			try ( // $line-nested.try3$
+					Resource r2 = new Resource() // $line-nested.open3$
+			) {
+				nop(r2); // $line-nested.body3$
+			} // $line-nested.close3$
+			catch (Exception e) {
+				nop(); // $line-nested.catch3$
+			} finally {
+				nop(); // $line-nested.finally3$
+			}
+
+		}
+	}
+
+	/**
+	 * In this case bytecode will contain 3 copies of <code>finally</code>
+	 * block, each containing 2 branches, resulting in 6 branches in total. One
+	 * could think that this is artifact of try-with-resources, but the same
+	 * happens without it.
+	 */
+	private static Object returnInCatch() {
+		try ( // $line-returnInCatch.try1$
+				Resource r = new Resource() // $line-returnInCatch.open$
+		) {
+			read(r);
+		} // $line-returnInCatch.close$
+		catch (Exception e) {
+			return null;
+		} finally {
+			nop(!f()); // $line-returnInCatch.finally1$
+		}
+
+		try { // $line-returnInCatch.try2$
+			read(new Resource());
+		} catch (Exception e) {
+			return null;
+		} finally {
+			nop(!f()); // $line-returnInCatch.finally2$
+		}
+
+		return null;
+	}
+
+	private static Object read(Object r1, Object r2, Object r3) {
+		return r1.toString() + r2.toString() + r3.toString();
+	}
+
+	private static Object read(Object r1) {
+		return r1.toString();
+	}
+
+	public static void main(String[] args) throws Exception {
+		test();
+		test2();
+		returnInBody();
+		nested();
+
+		returnInCatch();
+
+		empty();
+		handwritten();
+	}
+
+	/*
+	 * Corner cases
+	 */
+
+	private static void empty() throws Exception {
+		try ( // $line-empty.try$
+				Closeable r = new Resource() // $line-empty.open$
+		) {
+		} // $line-empty.close$
+	}
+
+	private static void handwritten() throws IOException {
+		Closeable r = new Resource();
+		Throwable primaryExc = null;
+		try {
+			nop(r);
+		} catch (Throwable t) {
+			primaryExc = t;
+			throw t;
+		} finally {
+			if (r != null) { // $line-handwritten$
+				if (primaryExc != null) {
+					try {
+						r.close();
+					} catch (Throwable suppressedExc) {
+						primaryExc.addSuppressed(suppressedExc);
+					}
+				} else {
+					r.close();
+				}
+			}
+		}
+	}
+
+	private static void throwInBody() throws IOException {
+		try ( // $line-throwInBody.try$
+				Closeable r = new Resource()) {
+			nop(r);
+			throw new RuntimeException();
+		} // $line-throwInBody.close$
+	}
+
+}