bundles/org.eclipse.test/src/org/eclipse/test/AbstractJUnitResultFormatter.java - platform/eclipse.platform.releng - Git at Google

 /*******************************************************************************
  * Copyright (c) 2018, 2020 Red Hat Inc. and others.
  *
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *     Lucas Bullen (Red Hat Inc.) - initial API and implementation
  *******************************************************************************/
 package org.eclipse.test;

 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
 import java.io.Closeable;
 import java.io.FileOutputStream;
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.Reader;
 import java.io.Writer;
 import java.nio.BufferOverflowException;
 import java.nio.ByteBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Objects;
 import java.util.Optional;

 import org.apache.tools.ant.Project;
 import org.apache.tools.ant.taskdefs.optional.junitlauncher.TestExecutionContext;
 import org.apache.tools.ant.taskdefs.optional.junitlauncher.TestResultFormatter;
 import org.apache.tools.ant.util.FileUtils;
 import org.junit.platform.engine.TestSource;
 import org.junit.platform.engine.support.descriptor.ClassSource;
 import org.junit.platform.launcher.TestIdentifier;
 import org.junit.platform.launcher.TestPlan;

 /**
  * Contains some common behaviour that's used by our internal {@link TestResultFormatter}s
  */
 abstract class AbstractJUnitResultFormatter implements TestResultFormatter {


 	protected static String NEW_LINE = System.lineSeparator();
 	protected TestExecutionContext context;

 	private SysOutErrContentStore sysOutStore;
 	private SysOutErrContentStore sysErrStore;

 	@Override
 	public void sysOutAvailable(final byte[] data) {
 		if (this.sysOutStore == null) {
 			this.sysOutStore = new SysOutErrContentStore(true);
 		}
 		try {
 			this.sysOutStore.store(data);
 		} catch (IOException e) {
 			handleException(e);
 			return;
 		}
 	}

 	@Override
 	public void sysErrAvailable(final byte[] data) {
 		if (this.sysErrStore == null) {
 			this.sysErrStore = new SysOutErrContentStore(false);
 		}
 		try {
 			this.sysErrStore.store(data);
 		} catch (IOException e) {
 			handleException(e);
 			return;
 		}
 	}

 	@Override
 	public void setContext(final TestExecutionContext context) {
 		this.context = context;
 	}

 	/**
 	 * @return Returns true if there's any stdout data, that was generated during the
 	 * tests, is available for use. Else returns false.
 	 */
 	boolean hasSysOut() {
 		return this.sysOutStore != null && this.sysOutStore.hasData();
 	}

 	/**
 	 * @return Returns true if there's any stderr data, that was generated during the
 	 * tests, is available for use. Else returns false.
 	 */
 	boolean hasSysErr() {
 		return this.sysErrStore != null && this.sysErrStore.hasData();
 	}

 	/**
 	 * @return Returns a {@link Reader} for reading any stdout data that was generated
 	 * during the test execution. It is expected that the {@link #hasSysOut()} be first
 	 * called to see if any such data is available and only if there is, then this method
 	 * be called
 	 * @throws IOException If there's any I/O problem while creating the {@link Reader}
 	 */
 	Reader getSysOutReader() throws IOException {
 		return this.sysOutStore.getReader();
 	}

 	/**
 	 * @return Returns a {@link Reader} for reading any stderr data that was generated
 	 * during the test execution. It is expected that the {@link #hasSysErr()} be first
 	 * called to see if any such data is available and only if there is, then this method
 	 * be called
 	 * @throws IOException If there's any I/O problem while creating the {@link Reader}
 	 */
 	Reader getSysErrReader() throws IOException {
 		return this.sysErrStore.getReader();
 	}

 	/**
 	 * Writes out any stdout data that was generated during the
 	 * test execution. If there was no such data then this method just returns.
 	 *
 	 * @param writer The {@link Writer} to use. Cannot be null.
 	 * @throws IOException If any I/O problem occurs during writing the data
 	 */
 	void writeSysOut(final Writer writer) throws IOException {
 		Objects.requireNonNull(writer, "Writer cannot be null");
 		this.writeFrom(this.sysOutStore, writer);
 	}

 	/**
 	 * Writes out any stderr data that was generated during the
 	 * test execution. If there was no such data then this method just returns.
 	 *
 	 * @param writer The {@link Writer} to use. Cannot be null.
 	 * @throws IOException If any I/O problem occurs during writing the data
 	 */
 	void writeSysErr(final Writer writer) throws IOException {
 		Objects.requireNonNull(writer, "Writer cannot be null");
 		this.writeFrom(this.sysErrStore, writer);
 	}

 	static Optional<TestIdentifier> traverseAndFindTestClass(final TestPlan testPlan, final TestIdentifier testIdentifier) {
 		if (isTestClass(testIdentifier).isPresent()) {
 			return Optional.of(testIdentifier);
 		}
 		final Optional<TestIdentifier> parent = testPlan.getParent(testIdentifier);
 		return parent.isPresent() ? traverseAndFindTestClass(testPlan, parent.get()) : Optional.empty();
 	}

 	static Optional<ClassSource> isTestClass(final TestIdentifier testIdentifier) {
 		if (testIdentifier == null) {
 			return Optional.empty();
 		}
 		final Optional<TestSource> source = testIdentifier.getSource();
 		if (!source.isPresent()) {
 			return Optional.empty();
 		}
 		final TestSource testSource = source.get();
 		if (testSource instanceof ClassSource) {
 			return Optional.of((ClassSource) testSource);
 		}
 		return Optional.empty();
 	}

 	private void writeFrom(final SysOutErrContentStore store, final Writer writer) throws IOException {
 		final char[] chars = new char[1024];
 		int numRead = -1;
 		try (final Reader reader = store.getReader()) {
 			while ((numRead = reader.read(chars)) != -1) {
 				writer.write(chars, 0, numRead);
 			}
 		}
 	}

 	@Override
 	public void close() throws IOException {
 		FileUtils.close(this.sysOutStore);
 		FileUtils.close(this.sysErrStore);
 	}

 	protected void handleException(final Throwable t) {
 		// we currently just log it and move on.
 		this.context.getProject().ifPresent(p -> p.log("Exception in listener "
 				+ AbstractJUnitResultFormatter.this.getClass().getName(), t, Project.MSG_DEBUG));
 	}


 	/*
     A "store" for sysout/syserr content that gets sent to the AbstractJUnitResultFormatter.
     This store first uses a relatively decent sized in-memory buffer for storing the sysout/syserr
     content. This in-memory buffer will be used as long as it can fit in the new content that
     keeps coming in. When the size limit is reached, this store switches to a file based store
     by creating a temporarily file and writing out the already in-memory held buffer content
     and any new content that keeps arriving to this store. Once the file has been created,
     the in-memory buffer will never be used any more and in fact is destroyed as soon as the
     file is created.
     Instances of this class are not thread-safe and users of this class are expected to use necessary thread
     safety guarantees, if they want to use an instance of this class by multiple threads.
 	 */
 	private static final class SysOutErrContentStore implements Closeable {
 		private static final int DEFAULT_CAPACITY_IN_BYTES = 50 * 1024; // 50 KB
 		private static final Reader EMPTY_READER = new Reader() {
 			@Override
 			public int read(final char[] cbuf, final int off, final int len) throws IOException {
 				return -1;
 			}

 			@Override
 			public void close() throws IOException {
 			}
 		};

 		private final String tmpFileSuffix;
 		private ByteBuffer inMemoryStore = ByteBuffer.allocate(DEFAULT_CAPACITY_IN_BYTES);
 		private boolean usingFileStore = false;
 		private Path filePath;
 		private FileOutputStream fileOutputStream;

 		SysOutErrContentStore(final boolean isSysOut) {
 			this.tmpFileSuffix = isSysOut ? ".sysout" : ".syserr";
 		}

 		void store(final byte[] data) throws IOException {
 			if (this.usingFileStore) {
 				this.storeToFile(data, 0, data.length);
 				return;
 			}
 			// we haven't yet created a file store and the data can fit in memory,
 			// so we write it in our buffer
 			try {
 				this.inMemoryStore.put(data);
 				return;
 			} catch (BufferOverflowException boe) {
 				// the buffer capacity can't hold this incoming data, so this
 				// incoming data hasn't been transferred to the buffer. let's
 				// now fall back to a file store
 				this.usingFileStore = true;
 			}
 			// since the content couldn't be transferred into in-memory buffer,
 			// we now create a file and transfer already (previously) stored in-memory
 			// content into that file, before finally transferring this new content
 			// into the file too. We then finally discard this in-memory buffer and
 			// just keep using the file store instead
 			this.fileOutputStream = createFileStore();
 			// first the existing in-memory content
 			storeToFile(this.inMemoryStore.array(), 0, this.inMemoryStore.position());
 			storeToFile(data, 0, data.length);
 			// discard the in-memory store
 			this.inMemoryStore = null;
 		}

 		private void storeToFile(final byte[] data, final int offset, final int length) throws IOException {
 			if (this.fileOutputStream == null) {
 				// no backing file was created so we can't do anything
 				return;
 			}
 			this.fileOutputStream.write(data, offset, length);
 		}

 		private FileOutputStream createFileStore() throws IOException {
 			this.filePath = Files.createTempFile(null, this.tmpFileSuffix);
 			this.filePath.toFile().deleteOnExit();
 			return new FileOutputStream(this.filePath.toFile());
 		}

 		/*
 		 * Returns a Reader for reading the sysout/syserr content. If there's no data
 		 * available in this store, then this returns a Reader which when used for read operations,
 		 * will immediately indicate an EOF.
 		 */
 		Reader getReader() throws IOException {
 			if (this.usingFileStore && this.filePath != null) {
 				// we use a FileReader here so that we can use the system default character
 				// encoding for reading the contents on sysout/syserr stream, since that's the
 				// encoding that System.out/System.err uses to write out the messages
 				return new BufferedReader(new FileReader(this.filePath.toFile()));
 			}
 			if (this.inMemoryStore != null) {
 				return new InputStreamReader(new ByteArrayInputStream(this.inMemoryStore.array(), 0, this.inMemoryStore.position()));
 			}
 			// no data to read, so we return an "empty" reader
 			return EMPTY_READER;
 		}

 		/*
 		 *  Returns true if this store has any data (either in-memory or in a file). Else
 		 *  returns false.
 		 */
 		boolean hasData() {
 			if (this.inMemoryStore != null && this.inMemoryStore.position() > 0) {
 				return true;
 			}
 			if (this.usingFileStore && this.filePath != null) {
 				return true;
 			}
 			return false;
 		}

 		@Override
 		public void close() throws IOException {
 			this.inMemoryStore = null;
 			FileUtils.close(this.fileOutputStream);
 			FileUtils.delete(this.filePath.toFile());
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2018, 2020 Red Hat Inc. and others.
	*
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Lucas Bullen (Red Hat Inc.) - initial API and implementation
	*******************************************************************************/
	package org.eclipse.test;

	import java.io.BufferedReader;
	import java.io.ByteArrayInputStream;
	import java.io.Closeable;
	import java.io.FileOutputStream;
	import java.io.FileReader;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.Reader;
	import java.io.Writer;
	import java.nio.BufferOverflowException;
	import java.nio.ByteBuffer;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.util.Objects;
	import java.util.Optional;

	import org.apache.tools.ant.Project;
	import org.apache.tools.ant.taskdefs.optional.junitlauncher.TestExecutionContext;
	import org.apache.tools.ant.taskdefs.optional.junitlauncher.TestResultFormatter;
	import org.apache.tools.ant.util.FileUtils;
	import org.junit.platform.engine.TestSource;
	import org.junit.platform.engine.support.descriptor.ClassSource;
	import org.junit.platform.launcher.TestIdentifier;
	import org.junit.platform.launcher.TestPlan;

	/**
	* Contains some common behaviour that's used by our internal {@link TestResultFormatter}s
	*/
	abstract class AbstractJUnitResultFormatter implements TestResultFormatter {


	protected static String NEW_LINE = System.lineSeparator();
	protected TestExecutionContext context;

	private SysOutErrContentStore sysOutStore;
	private SysOutErrContentStore sysErrStore;

	@Override
	public void sysOutAvailable(final byte[] data) {
	if (this.sysOutStore == null) {
	this.sysOutStore = new SysOutErrContentStore(true);
	}
	try {
	this.sysOutStore.store(data);
	} catch (IOException e) {
	handleException(e);
	return;
	}
	}

	@Override
	public void sysErrAvailable(final byte[] data) {
	if (this.sysErrStore == null) {
	this.sysErrStore = new SysOutErrContentStore(false);
	}
	try {
	this.sysErrStore.store(data);
	} catch (IOException e) {
	handleException(e);
	return;
	}
	}

	@Override
	public void setContext(final TestExecutionContext context) {
	this.context = context;
	}

	/**
	* @return Returns true if there's any stdout data, that was generated during the
	* tests, is available for use. Else returns false.
	*/
	boolean hasSysOut() {
	return this.sysOutStore != null && this.sysOutStore.hasData();
	}

	/**
	* @return Returns true if there's any stderr data, that was generated during the
	* tests, is available for use. Else returns false.
	*/
	boolean hasSysErr() {
	return this.sysErrStore != null && this.sysErrStore.hasData();
	}

	/**
	* @return Returns a {@link Reader} for reading any stdout data that was generated
	* during the test execution. It is expected that the {@link #hasSysOut()} be first
	* called to see if any such data is available and only if there is, then this method
	* be called
	* @throws IOException If there's any I/O problem while creating the {@link Reader}
	*/
	Reader getSysOutReader() throws IOException {
	return this.sysOutStore.getReader();
	}

	/**
	* @return Returns a {@link Reader} for reading any stderr data that was generated
	* during the test execution. It is expected that the {@link #hasSysErr()} be first
	* called to see if any such data is available and only if there is, then this method
	* be called
	* @throws IOException If there's any I/O problem while creating the {@link Reader}
	*/
	Reader getSysErrReader() throws IOException {
	return this.sysErrStore.getReader();
	}

	/**
	* Writes out any stdout data that was generated during the
	* test execution. If there was no such data then this method just returns.
	*
	* @param writer The {@link Writer} to use. Cannot be null.
	* @throws IOException If any I/O problem occurs during writing the data
	*/
	void writeSysOut(final Writer writer) throws IOException {
	Objects.requireNonNull(writer, "Writer cannot be null");
	this.writeFrom(this.sysOutStore, writer);
	}

	/**
	* Writes out any stderr data that was generated during the
	* test execution. If there was no such data then this method just returns.
	*
	* @param writer The {@link Writer} to use. Cannot be null.
	* @throws IOException If any I/O problem occurs during writing the data
	*/
	void writeSysErr(final Writer writer) throws IOException {
	Objects.requireNonNull(writer, "Writer cannot be null");
	this.writeFrom(this.sysErrStore, writer);
	}

	static Optional<TestIdentifier> traverseAndFindTestClass(final TestPlan testPlan, final TestIdentifier testIdentifier) {
	if (isTestClass(testIdentifier).isPresent()) {
	return Optional.of(testIdentifier);
	}
	final Optional<TestIdentifier> parent = testPlan.getParent(testIdentifier);
	return parent.isPresent() ? traverseAndFindTestClass(testPlan, parent.get()) : Optional.empty();
	}

	static Optional<ClassSource> isTestClass(final TestIdentifier testIdentifier) {
	if (testIdentifier == null) {
	return Optional.empty();
	}
	final Optional<TestSource> source = testIdentifier.getSource();
	if (!source.isPresent()) {
	return Optional.empty();
	}
	final TestSource testSource = source.get();
	if (testSource instanceof ClassSource) {
	return Optional.of((ClassSource) testSource);
	}
	return Optional.empty();
	}

	private void writeFrom(final SysOutErrContentStore store, final Writer writer) throws IOException {
	final char[] chars = new char[1024];
	int numRead = -1;
	try (final Reader reader = store.getReader()) {
	while ((numRead = reader.read(chars)) != -1) {
	writer.write(chars, 0, numRead);
	}
	}
	}

	@Override
	public void close() throws IOException {
	FileUtils.close(this.sysOutStore);
	FileUtils.close(this.sysErrStore);
	}

	protected void handleException(final Throwable t) {
	// we currently just log it and move on.
	this.context.getProject().ifPresent(p -> p.log("Exception in listener "
	+ AbstractJUnitResultFormatter.this.getClass().getName(), t, Project.MSG_DEBUG));
	}


	/*
	A "store" for sysout/syserr content that gets sent to the AbstractJUnitResultFormatter.
	This store first uses a relatively decent sized in-memory buffer for storing the sysout/syserr
	content. This in-memory buffer will be used as long as it can fit in the new content that
	keeps coming in. When the size limit is reached, this store switches to a file based store
	by creating a temporarily file and writing out the already in-memory held buffer content
	and any new content that keeps arriving to this store. Once the file has been created,
	the in-memory buffer will never be used any more and in fact is destroyed as soon as the
	file is created.
	Instances of this class are not thread-safe and users of this class are expected to use necessary thread
	safety guarantees, if they want to use an instance of this class by multiple threads.
	*/
	private static final class SysOutErrContentStore implements Closeable {
	private static final int DEFAULT_CAPACITY_IN_BYTES = 50 * 1024; // 50 KB
	private static final Reader EMPTY_READER = new Reader() {
	@Override
	public int read(final char[] cbuf, final int off, final int len) throws IOException {
	return -1;
	}

	@Override
	public void close() throws IOException {
	}
	};

	private final String tmpFileSuffix;
	private ByteBuffer inMemoryStore = ByteBuffer.allocate(DEFAULT_CAPACITY_IN_BYTES);
	private boolean usingFileStore = false;
	private Path filePath;
	private FileOutputStream fileOutputStream;

	SysOutErrContentStore(final boolean isSysOut) {
	this.tmpFileSuffix = isSysOut ? ".sysout" : ".syserr";
	}

	void store(final byte[] data) throws IOException {
	if (this.usingFileStore) {
	this.storeToFile(data, 0, data.length);
	return;
	}
	// we haven't yet created a file store and the data can fit in memory,
	// so we write it in our buffer
	try {
	this.inMemoryStore.put(data);
	return;
	} catch (BufferOverflowException boe) {
	// the buffer capacity can't hold this incoming data, so this
	// incoming data hasn't been transferred to the buffer. let's
	// now fall back to a file store
	this.usingFileStore = true;
	}
	// since the content couldn't be transferred into in-memory buffer,
	// we now create a file and transfer already (previously) stored in-memory
	// content into that file, before finally transferring this new content
	// into the file too. We then finally discard this in-memory buffer and
	// just keep using the file store instead
	this.fileOutputStream = createFileStore();
	// first the existing in-memory content
	storeToFile(this.inMemoryStore.array(), 0, this.inMemoryStore.position());
	storeToFile(data, 0, data.length);
	// discard the in-memory store
	this.inMemoryStore = null;
	}

	private void storeToFile(final byte[] data, final int offset, final int length) throws IOException {
	if (this.fileOutputStream == null) {
	// no backing file was created so we can't do anything
	return;
	}
	this.fileOutputStream.write(data, offset, length);
	}

	private FileOutputStream createFileStore() throws IOException {
	this.filePath = Files.createTempFile(null, this.tmpFileSuffix);
	this.filePath.toFile().deleteOnExit();
	return new FileOutputStream(this.filePath.toFile());
	}

	/*
	* Returns a Reader for reading the sysout/syserr content. If there's no data
	* available in this store, then this returns a Reader which when used for read operations,
	* will immediately indicate an EOF.
	*/
	Reader getReader() throws IOException {
	if (this.usingFileStore && this.filePath != null) {
	// we use a FileReader here so that we can use the system default character
	// encoding for reading the contents on sysout/syserr stream, since that's the
	// encoding that System.out/System.err uses to write out the messages
	return new BufferedReader(new FileReader(this.filePath.toFile()));
	}
	if (this.inMemoryStore != null) {
	return new InputStreamReader(new ByteArrayInputStream(this.inMemoryStore.array(), 0, this.inMemoryStore.position()));
	}
	// no data to read, so we return an "empty" reader
	return EMPTY_READER;
	}

	/*
	* Returns true if this store has any data (either in-memory or in a file). Else
	* returns false.
	*/
	boolean hasData() {
	if (this.inMemoryStore != null && this.inMemoryStore.position() > 0) {
	return true;
	}
	if (this.usingFileStore && this.filePath != null) {
	return true;
	}
	return false;
	}

	@Override
	public void close() throws IOException {
	this.inMemoryStore = null;
	FileUtils.close(this.fileOutputStream);
	FileUtils.delete(this.filePath.toFile());
	}
	}
	}