Throwable cause = throwable.getCause();
            if (cause == null || cause.getMessage() == null || cause == throwable) {
                return false;
            }
            return throwable.getMessage() == null || !throwable.getMessage().contains(cause.getMessage());
        }

    }

    public static class FileLocationAdapter extends TypeAdapter<FileLocation> {

            logEvent(descriptor, TestLogEvent.STANDARD_OUT, TextUtil.indent(outputEvent.getMessage(), INDENT) + "\n");
        } else if (outputEvent.getDestination() == TestOutputEvent.Destination.StdErr
                && isLoggedEventType(TestLogEvent.STANDARD_ERROR)) {
            logEvent(descriptor, TestLogEvent.STANDARD_ERROR, TextUtil.indent(outputEvent.getMessage(), INDENT) + "\n");
        }
    }

interface GreetingPluginExtension {
    Property<String> getMessage()
}

class GreetingPlugin implements Plugin<Project> {
    void apply(Project project) {
        // Add the 'greeting' extension object
        def extension = project.extensions.create('greeting', GreetingPluginExtension)
        // Add a task that uses configuration from the extension object
        project.task('hello') {
            doLast {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.execution.history.changes;

public interface Change {
    String getMessage();

            super(name, publicType, params, false, new CustomMessageMissingMethodException(name, publicType, message, params));
        }

        @Override
        public String getMessage() {
            return getCause().getMessage();
        }
    }

    private static class CustomMessageMissingMethodException extends MissingMethodException {
        private final String message;

            return new Metadata(new MetadataStaxReader().read(input, false));
        } catch (IOException | XMLStreamException e) {
            throw new RepositoryException("Could not parse metadata " + metadataPath + ": " + e.getMessage(), e);
        }
    }

    private void write(Path metadataPath, Metadata metadata) throws RepositoryException {
        try {
            Files.createDirectories(metadataPath.getParent());

    private static final long serialVersionUID = 1L;

    public UnsupportedEncodingRuntimeException(final UnsupportedEncodingException cause) {
        super("ECL0105", new Object[] { cause.getMessage() }, cause);
    }

                }
                errorMessage = stdout.toString();
            }
        } catch (IOException e) {
            errorMessage = e.getMessage();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            errorMessage = e.getMessage();
        }
        if (errorMessage != null) {
            logger.log("Could not set executable permissions for: " + gradleCommand.getAbsolutePath());

            try {
                while( used == 0 ) {
                    lock.wait();
                }
            } catch( InterruptedException ie ) {
                throw new IOException( ie.getMessage() );
            }
            result = pipe_buf[beg_idx] & 0xFF;
            beg_idx = ( beg_idx + 1 ) % pipe_buf.length;
        }
        return result;
    }
    public int read( byte[] b ) throws IOException {

import java.io.Serializable;

@UsedByScanPlugin
public interface PlaceholderExceptionSupport extends Serializable {

    StackTraceElement[] getStackTrace();

    String getExceptionClassName();

    String getMessage();