}

        ILoggerFactory loggerFactory = LoggerFactory.getILoggerFactory();
        if (!(loggerFactory instanceof OutputEventListenerBackedLoggerContext)) {
            // Cannot configure Slf4j logger. This will happen if:
            // - Tests are executed with a custom classloader (e.g using `java.system.class.loader`)
            // - Tests are run with `--module-path`, effectively hiding Gradle classes
            return;
        }

import java.io.File;

/**
 * Android-incompatible tests for {@link FileBackedOutputStream}.
 *
 * @author Chris Nokleberg
 */
@AndroidIncompatible // Finalization probably just doesn't happen fast enough?
public class FileBackedOutputStreamAndroidIncompatibleTest extends IoTestCase {

  public void testFinalizeDeletesFile() throws Exception {
    byte[] data = newPreFilledByteArray(100);

            if (filterSpec.isSatisfiedBy(element)) {
                filtered.add(element);
            }
        }
        // If none of the lines match the filter, keep the original stacktrace
        // It might happen when test method was inherited from a base class.
        // In that case, "derived" test class never appears in the stacktrace,
        // and it is better to show the stacktrace as is rather than truncate it completely.

	// inconsistency similar to the one above. Hence the requirement
	// for atomic counter mode: according to package atomic docs,
	// "...operations that happen in a specific order on one thread,
	// will always be observed to happen in exactly that order by
	// another thread". Thus we can be sure that there will be no
	// inconsistency when reading the counter array from the thread
	// running ClearCounters.

      required: true

  - type: textarea
    attributes:
      label: Expected Behavior
      description: What did you expect to happen?
    validations:
      required: true

  - type: textarea
    attributes:
      label: Actual Behavior
      description: What actually happened?
    validations:
      required: true

  - type: dropdown
    attributes:
      label: Packages

        TreeFormatter fmt = new TreeFormatter();
        fmt.node("Cannot select a variant of '" + module.getId());
        fmt.append("' because different values for attribute '");
        fmt.append(attribute.toString());
        fmt.append("' are requested");
        fmt.startChildren();
        Set<EdgeState> incomingEdges = module.getIncomingEdges();

        if (!(command instanceof Build)) {
            throw new IllegalStateException(String.format("%1$s command action received a command that isn't Build (command is %2$s), this shouldn't happen", this.getClass(), command.getClass()));
        }

        doBuild(execution, (Build)command);
    }

    /**
     * Note that the build param is the same object as execution.getCommand(), just “pre casted”.

     */
    Set<ResolvedVariant> getVariants();

    /**
     * The provider may have been selected thanks to a different attribute set than the one from
     * the consuming configuration. This can happen whenever a dependency has additional attributes,
     * in which case it may override attributes from the configuration itself.
     *
     * @return attributes which will override the consumer attributes
     */

// event before advancing into the next generation at all.
// It turns out this situation is pretty rare; the GoStatus
// event almost always shows up first in practice. But it
// can and did happen.

package main

import (
	"internal/trace"
	"internal/trace/event/go122"
	testgen "internal/trace/internal/testgen/go122"
)

func main() {
	testgen.Main(gen)
}

func gen(t *testgen.Trace) {
	g1 := t.Generation(1)

	Err error // unused
}

func (w StreamWriter) Write(src []byte) (n int, err error) {
	c := make([]byte, len(src))
	w.S.XORKeyStream(c, src)
	n, err = w.W.Write(c)
	if n != len(src) && err == nil { // should never happen
		err = io.ErrShortWrite
	}
	return
}

// Close closes the underlying Writer and returns its Close return value, if the Writer
// is also an io.Closer. Otherwise it returns nil.