return c;
                }
                return value;
            }
        };
    }

    @SuppressWarnings("StringEquality")
    private static final class ModelVisitor {
        private final InnerInterpolator interpolator;

        ModelVisitor(InnerInterpolator interpolator) {
            this.interpolator = interpolator;
        }

        void visit(Model model) {

     * classloader.
     */
    private static final ClassLoader PARENT_CLASSLOADER = ClassWorld.class.getClassLoader();

    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final ClassWorld world;

    private final ClassRealm containerRealm;

    // this is a live injected collection
    private final List<ClassRealmManagerDelegate> delegates;

public final class Smb3KeyDerivation {

    private static final byte[] SIGNCONTEXT_300 = toCBytes("SmbSign");
    private static final byte[] SIGNLABEL_300 = toCBytes("SMB2AESCMAC");
    private static final byte[] SIGNLABEL_311 = toCBytes("SMBSigningKey");

    private static final byte[] APPCONTEXT_300 = toCBytes("SmbRpc");
    private static final byte[] APPLABEL_300 = toCBytes("SMB2APP");

        "com.squareup.okhttp3.tls",
        "com.squareup.okhttp3.urlconnection",
      )

    /** Equinox must also be on the testing classpath.  */
    private const val RESOLVE_OSGI_FRAMEWORK = "org.eclipse.osgi"
    private const val RESOLVE_JAVA_VERSION = "JavaSE-1.8"
    private const val REPO_NAME = "OsgiTest"
  }

    private static final Object[] EMPTY_ARGS = new Object[0];

    private final String propertyName;

    private final Class<?> propertyType;

    private Method readMethod;

    private Method writeMethod;

    private Field field;

    private final BeanDesc beanDesc;

    private Constructor<?> stringConstructor;

    private Method valueOfMethod;

  /** A request body that fires events when it completes. */
  private inner class RequestBodySink(
    delegate: Sink,
    /** The exact number of bytes to be written, or -1L if that is unknown. */
    private val contentLength: Long,
    private val isSocket: Boolean,
  ) : ForwardingSink(delegate) {
    private var completed = false
    private var bytesReceived = 0L
    private var invokeStartEvent = isSocket
    private var closed = false

      return description;
    }
  }

  private Target empty;
  private Target disjoint;
  private Target superset;
  private Target nonEmptyProperSubset;
  private Target sameElements;
  private Target partialOverlap;
  private Target containsDuplicates;
  private Target nullSingleton;

  @Override
  public void setUp() throws Exception {
    super.setUp();

public class DefaultMaven implements Maven {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final Lookup lookup;

    private final ExecutionEventCatapult eventCatapult;

    private final LegacySupport legacySupport;

    private final SessionScope sessionScope;

    private final RepositorySystemSessionFactory repositorySessionFactory;

    private final GraphBuilder graphBuilder;

import spock.lang.TempDir

class FindBrokenInternalLinksTest extends Specification {
    @TempDir
    private File projectDir
    private File docsRoot
    private File samplesRoot
    private File sampleDoc
    private File sampleSampleDoc
    private File releaseNotes
    private File linkErrors

    private setup() {
        docsRoot = new File(projectDir, "docsRoot")
        new File(docsRoot, 'javadoc').mkdirs()

 *
 */
class Xpp3DomNodeIterator implements NodeIterator {

    private NodePointer parent;

    private NodeTest test;

    private XmlNode node;

    private List<XmlNode> children;

    private List<XmlNode> filteredChildren = new ArrayList<>();

    private int filteredIndex;

    private XmlNode child;

    private int position;