class ConsumerPomArtifactTransformerTest {

    @Test
    void transform() throws Exception {
        RepositorySystemSession systemSessionMock = Mockito.mock(RepositorySystemSession.class);
        SessionData sessionDataMock = Mockito.mock(SessionData.class);
        when(systemSessionMock.getData()).thenReturn(sessionDataMock);
        when(sessionDataMock.get(any())).thenReturn(new NoTransformerContext());

    }

    def visitsSignature() {
        TypeMetaData.SignatureVisitor visitor = Mock()

        when:
        type.visitSignature(visitor)

        then:
        1 * visitor.visitType('org.gradle.SomeType')
        0 * visitor._
    }

    def visitsSignatureForArrayType() {
        TypeMetaData.SignatureVisitor visitor = Mock()
        type.arrayDimensions = 2

        when:

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.mock;

public class DefaultSessionTest {

    @Test
    void testRootDirectoryWithNull() {
        RepositorySystemSession rss = new DefaultRepositorySystemSession(h -> false);

      };

  public void testSchedule() {
    MockExecutor mock = new MockExecutor();
    TestExecutor testExecutor = new TestExecutor(mock);

    @SuppressWarnings("unused") // https://errorprone.info/bugpattern/FutureReturnValueIgnored
    Future<?> possiblyIgnoredError = testExecutor.schedule(DO_NOTHING, 10, TimeUnit.MINUTES);
    mock.assertLastMethodCalled("scheduleRunnable", 10, TimeUnit.MINUTES);

        RepositorySystemSession session = mock(RepositorySystemSession.class);
        when(session.getLocalRepository()).thenReturn(localRepository);

        Artifact localRepositoryArtifact = mock(Artifact.class);
        when(localRepositoryArtifact.getFile()).thenReturn(new File(baseDir, "some/path/within"));

        Artifact nonLocalReposioryArtifact = mock(Artifact.class);

              public T apply(Object delegate) {
                T mock = mock(forwarderClass, CALLS_REAL_METHODS);
                try {
                  T stubber = doReturn(delegate).when(mock);
                  DELEGATE_METHOD.invoke(stubber);
                } catch (Exception e) {
                  throw new RuntimeException(e);
                }
                return mock;
              }
            });
  }

  private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  @SuppressWarnings("DoNotMock")
  @Override
  protected void setUp() throws Exception {
    super.setUp();
    hasher = mock(Hasher.class);
    hashFunction = mock(HashFunction.class);

    when(hashFunction.newHasher()).thenReturn(hasher);
  }

  public void testWrite_putSingleByte() throws Exception {
    int b = 'q';

import spock.lang.Specification
import gradlebuild.docs.dsl.source.model.TypeMetaData

class TypeNameResolverTest extends Specification {
    final ClassMetaDataRepository<ClassMetaData> metaDataRepository = Mock()
    final ClassMetaData classMetaData = Mock()
    final TypeNameResolver typeNameResolver = new TypeNameResolver(metaDataRepository)

    def resolvesFullyQualifiedClassName() {
        when:

import gradlebuild.docs.dsl.source.model.MethodMetaData

class JavadocConverterTest extends XmlSpecification {
    final ClassMetaData classMetaData = Mock()
    final JavadocLinkConverter linkConverter = Mock()
    final GenerationListener listener = Mock()
    final JavadocConverter parser = new JavadocConverter(document, linkConverter)

    def respectsLineIndentation() {
        _ * classMetaData.rawCommentText >> '''

  private final ByteArrayOutputStream buffer = new ByteArrayOutputStream();

  @SuppressWarnings("DoNotMock")
  @Override
  protected void setUp() throws Exception {
    super.setUp();
    hasher = mock(Hasher.class);
    hashFunction = mock(HashFunction.class);

    when(hashFunction.newHasher()).thenReturn(hasher);
  }

  public void testWrite_putSingleByte() throws Exception {
    int b = 'q';