@Mock
    private Encodable mockInputData;

    @Mock
    private Encodable mockOutputData;

    private static final int TEST_CONTROL_CODE = Smb2IoctlRequest.FSCTL_DFS_GET_REFERRALS;
    private static final byte[] TEST_FILE_ID = new byte[16];
    private static final byte[] TEST_OUTPUT_BUFFER = new byte[1024];

    @BeforeEach
    void setUp() {
        Arrays.fill(TEST_FILE_ID, (byte) 0x42);
    }

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    // Simple FileEntry stub for tests
    private static final class FE implements FileEntry {
        private final String name;

        FE(String name) {
            this.name = name;
        }

        @Override
        public String getName() {
            return name;
        }

@GwtCompatible
@NullUnmarked
public class UnsignedIntsTest extends TestCase {
  private static final long[] UNSIGNED_INTS = {
    0L,
    1L,
    2L,
    3L,
    0x12345678L,
    0x5a4316b8L,
    0x6cf78a4bL,
    0xff1a618bL,
    0xfffffffdL,
    0xfffffffeL,
    0xffffffffL
  };

  private static final int LEAST = (int) 0L;
  private static final int GREATEST = (int) 0xffffffffL;

  public void testCheckedCast() {

    @DoNotCall
    @Deprecated
    @Override
    public final ImmutableSortedMap<K, V> buildKeepingLast() {
      // TODO(emcmanus): implement
      throw new UnsupportedOperationException(
          "ImmutableSortedMap.Builder does not yet implement buildKeepingLast()");
    }
  }

  private final transient RegularImmutableSortedSet<K> keySet;
  private final transient ImmutableList<V> valueList;

    }
  }

  @J2ktIncompatible
  @GwtIncompatible // EnumSet.complementOf
  private static final class RoundToDoubleTester {
    private final BigInteger input;
    private final Map<RoundingMode, Double> expectedValues = new EnumMap<>(RoundingMode.class);
    private boolean unnecessaryShouldThrow = false;

    RoundToDoubleTester(BigInteger input) {

        DependencyResolutionResult getResult();
    }

    /**
     * CacheRecord
     */
    class CacheRecord {

        private final Set<Artifact> artifacts;

        private final LifecycleExecutionException exception;

        CacheRecord(Set<Artifact> artifacts) {
            this.artifacts = artifacts;
            this.exception = null;
        }

import static java.util.Objects.requireNonNull;

/**
 * Proto-{@link Lookup} offer ways to provide early components to invoker.
 */
public class ProtoLookup implements Lookup {
    private final Map<Class<?>, Object> components;

    private ProtoLookup(Map<Class<?>, Object> components) {
        this.components = components;
    }

    @Override
    public <T> T lookup(Class<T> type) {

import static java.util.Objects.requireNonNull;

/**
 */
@Named
@Singleton
public class DefaultArtifactHandlerManager extends AbstractEventSpy implements ArtifactHandlerManager {
    private final TypeRegistry typeRegistry;

    private final ConcurrentHashMap<String, ArtifactHandler> allHandlers;

    @Inject
    public DefaultArtifactHandlerManager(TypeRegistry typeRegistry) {

 * a time.
 *
 * @author Chris Nokleberg
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
final class MultiInputStream extends InputStream {

  private final Iterator<? extends ByteSource> it;
  private @Nullable InputStream in;

  /**
   * Creates a new instance.
   *

 * SettableFuture}).
 *
 * <p>Useful for testing the behavior of Future utilities against odd futures.
 *
 * @author Anthony Zana
 */
@GwtCompatible
@NullUnmarked
final class UncheckedThrowingFuture<V> extends AbstractFuture<V> {

  public static <V> ListenableFuture<V> throwingError(Error error) {
    UncheckedThrowingFuture<V> future = new UncheckedThrowingFuture<V>();