/**
 * A bunch of information about the client used to start this build.
 */
public interface BuildClientMetaData {
    /**
     * Appends a message to the given appendable describing how to run the client with the given command-line args.
     */
    void describeCommand(Appendable output, String... args);

            }
        });
    }

    private String getDescriptor() {
        return factory.create();
    }

    @Override
    public void describeTo(Appendable appendable) {
        try {
            appendable.append(getDescriptor());
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    @Override
    public boolean equals(Object o) {

	if err != nil {
		t.Fatal(err)
	}

	err = fs.AppendFile(context.Background(), "voldir", "/file", []byte("hello"))
	if err != nil {
		t.Fatal(err)
	}

	// Try to create a file that includes a file in its path components.
	// In *nix, this returns syscall.ENOTDIR while in windows we receive the following error.
	err = fs.AppendFile(context.Background(), "voldir", "/file/obj1", []byte("hello"))

    private int hashCode;

    public MethodModelRuleDescriptor(WeaklyTypeReferencingMethod<?, ?> method) {
        this.method = method;
    }

    @Override
    public void describeTo(Appendable appendable) {
        try {
            appendable.append(getDescription());
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }

    private String getDescription() {

package org.gradle.internal.logging.text;

import org.gradle.api.logging.LogLevel;

public class StreamingStyledTextOutputFactory extends AbstractStyledTextOutputFactory {
    private final Appendable target;

    public StreamingStyledTextOutputFactory(Appendable target) {
        this.target = target;
    }

    @Override
    public StyledTextOutput create(String logCategory, LogLevel logLevel) {

	// Create test files for further reading.
	for i, appendFile := range appendFiles {
		err = xlStorage.AppendFile(context.Background(), volume, appendFile.fileName, []byte("hello, world"))
		if err != appendFile.expectedErr {
			t.Fatalf("Creating file failed: %d %#v, expected: %s, got: %s", i+1, appendFile, appendFile.expectedErr, err)
		}
	}

	{
		buf := make([]byte, 5)

/**
 * Writer that places all output on an {@link Appendable} target. If the target is {@link Flushable}
 * or {@link Closeable}, flush()es and close()s will also be delegated to the target.
 *
 * @author Alan Green
 * @author Sebastian Kanthak
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
class AppendableWriter extends Writer {
  private final Appendable target;
  private boolean closed;

  /**

   * Copies all characters between the {@link Readable} and {@link Appendable} objects. Does not
   * close or flush either object.
   *
   * @param from the object to read from
   * @param to the object to write to
   * @return the number of characters copied
   * @throws IOException if an I/O error occurs
   */
  @CanIgnoreReturnValue
  public static long copy(Readable from, Appendable to) throws IOException {

    def "should filter rules removing duplicates and excluding creators"() {
        ModelRuleDescriptor creator = Mock()
        creator.describeTo(_) >> { Appendable a ->
            a.append("creator")
        }

        ModelRuleDescriptor mutator = Mock()
        mutator.describeTo(_) >> { Appendable a ->
            a.append("mutator")
        }

        ModelNode modelNode = Mock()
        modelNode.getDescriptor() >> creator

        return output.toString();
    }

    public static void print(Appendable output, Failure failure, FailurePrinterListener listener) {
        new Job(output, listener).print(failure);
    }

    private static final class Job {

        private final FailurePrinterListener listener;

        private final Appendable builder;