import jcifs.smb.Handler;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbNamedPipe;


/**
 * @author mbechler
 *
 */
public class CIFSContextWrapper implements CIFSContext {

    private final CIFSContext delegate;
    private Handler wrappedHandler;


    /**
     * @param delegate
     *            context to delegate non-override methods to
     * 
     */

 * limitations under the License.
 */
package gradlebuild.docs.dsl.source.model

import spock.lang.Specification

class TypeMetaDataTest extends Specification {
    final TypeMetaData type = new TypeMetaData('org.gradle.SomeType')

    def rawTypeForSimpleType() {
        expect:
        type.rawType.signature == 'org.gradle.SomeType'
    }

    def rawTypeForArrayType() {

```java
/** This interceptor compresses the HTTP request body. Many webservers can't handle this! */
final class GzipRequestInterceptor implements Interceptor {
  @Override public Response intercept(Interceptor.Chain chain) throws IOException {
    Request originalRequest = chain.request();

        .withSetUp(parentBuilder.getSetUp())
        .withTearDown(parentBuilder.getTearDown())
        .createTestSuite();
  }

  static class ElementSetGenerator<E> implements TestSetGenerator<E> {
    final OneSizeTestContainerGenerator<Collection<E>, E> gen;

    ElementSetGenerator(OneSizeTestContainerGenerator<Collection<E>, E> gen) {
      this.gen = gen;
    }

    @Override

    return new RegularImmutableBiMap<K, V>(ImmutableMap.ofEntries(entries));
  }

  public static <K, V> Builder<K, V> builder() {
    return new Builder<K, V>();
  }

  public static final class Builder<K, V> extends ImmutableMap.Builder<K, V> {

    public Builder() {}

    Builder(int initCapacity) {
      super(initCapacity);
    }

    @CanIgnoreReturnValue
    @Override

import org.eclipse.sisu.Priority;

/**
 */
@Named
@Singleton
@Priority(10)
@Deprecated
public class TestRepositorySystem implements RepositorySystem {

    private final ModelReader modelReader;

    private final ArtifactFactory artifactFactory;

    public TestRepositorySystem() {
        this(null, null);
    }

    @Inject

  public static <K extends @Nullable Object, V extends @Nullable Object>
      CompactLinkedHashMap<K, V> createWithExpectedSize(int expectedSize) {
    return new CompactLinkedHashMap<>(expectedSize);
  }

  private static final int ENDPOINT = -2;

  /**
   * Contains the link pointers corresponding with the entries, in the range of [0, size()). The
   * high 32 bits of each long is the "prev" pointer, whereas the low 32 bits is the "succ" pointer

  }

  private final int k;
  private final Comparator<? super T> comparator;

  /*
   * We are currently considering the elements in buffer in the range [0, bufferSize) as candidates
   * for the top k elements. Whenever the buffer is filled, we quickselect the top k elements to the
   * range [0, k) and ignore the remaining elements.
   */
  private final @Nullable T[] buffer;
  private int bufferSize;

 *
 * @author Charles Fry
 * @since 11.0
 */
@GwtCompatible
@J2ktIncompatible
@ElementTypesAreNonnullByDefault
public final class AtomicLongMap<K> implements Serializable {
  private final ConcurrentHashMap<K, AtomicLong> map;

  private AtomicLongMap(ConcurrentHashMap<K, AtomicLong> map) {
    this.map = checkNotNull(map);
  }

  /** Creates an {@code AtomicLongMap}. */

  private static final class PickyIterable<E> implements Iterable<E> {
    final List<E> elements;
    int modCount = 0;

    PickyIterable(E... elements) {
      this.elements = new ArrayList<E>(asList(elements));
    }

    @Override
    public Iterator<E> iterator() {
      return new PickyIterator();
    }

    final class PickyIterator implements Iterator<E> {