ByteSource source = newByteSource(0, 50);
    int[] counter = new int[1];
    ByteSource checker =
        new ByteSource() {
          @Override
          public InputStream openStream() throws IOException {
            if (counter[0]++ != 0) {
              throw new IllegalStateException("More than one source open");
            }
            return new FilterInputStream(source.openStream()) {
              @Override

        assertFalse(loopback.isUsableForChannel());
    }

    @Test
    void testGetScore() {
        NetworkInterfaceInfo basic = new NetworkInterfaceInfo(testAddress, 1000);
        assertEquals(1000, basic.getScore()); // Base score is link speed

        NetworkInterfaceInfo fast = new NetworkInterfaceInfo(testAddress, 10000);

            pipe.send(new TransWaitNamedPipe(path), new TransWaitNamedPipeResponse());
            pipe.send(new TransCallNamedPipe(path, b, off, len), new TransCallNamedPipeResponse(pipe));
        } else if ((pipe.pipeType & SmbNamedPipe.PIPE_TYPE_TRANSACT) == SmbNamedPipe.PIPE_TYPE_TRANSACT) {
            ensureOpen();
            final TransTransactNamedPipe req = new TransTransactNamedPipe(pipe.fid, b, off, len);

        a2.setDependencyFilter(new ExcludesArtifactFilter(Arrays.asList("foo")));

        // sanity checks
        assertNotSame(a1, a2);
        assertNotSame(lr1, lr2);
        assertNotSame(rr1, rr2);

        DefaultMavenMetadataCache.CacheKey k1 =
                new DefaultMavenMetadataCache.CacheKey(a1, false, lr1, Collections.singletonList(rr1));
        DefaultMavenMetadataCache.CacheKey k2 =

          }
        };
    static final PermittedMetaException UOE =
        new PermittedMetaException("UnsupportedOperationException") {
          @Override
          boolean isPermitted(Exception exception) {
            return exception instanceof UnsupportedOperationException;
          }
        };
    static final PermittedMetaException ISE =
        new PermittedMetaException("IllegalStateException") {
          @Override

    testRotate(new byte[] {1, 2}, -1, new byte[] {2, 1});
    testRotate(new byte[] {1, 2}, -2, new byte[] {1, 2});
    testRotate(new byte[] {1, 2}, 0, new byte[] {1, 2});
    testRotate(new byte[] {1, 2}, 1, new byte[] {2, 1});
    testRotate(new byte[] {1, 2}, 2, new byte[] {1, 2});
    testRotate(new byte[] {1, 2}, 3, new byte[] {2, 1});

    testRotate(new byte[] {1, 2, 3}, -5, new byte[] {3, 1, 2});

  public void testRotate() {
    testRotate(new char[] {}, -1, new char[] {});
    testRotate(new char[] {}, 0, new char[] {});
    testRotate(new char[] {}, 1, new char[] {});

    testRotate(new char[] {'1'}, -2, new char[] {'1'});
    testRotate(new char[] {'1'}, -1, new char[] {'1'});
    testRotate(new char[] {'1'}, 0, new char[] {'1'});
    testRotate(new char[] {'1'}, 1, new char[] {'1'});

      String read(ByteSource byteSource, Charset cs) throws IOException {
        return new String(byteSource.read(), cs);
      }
    },
    USING_CHARSTREAMS_COPY {
      @Override
      String read(ByteSource byteSource, Charset cs) throws IOException {
        StringBuilder sb = new StringBuilder();
        try (InputStreamReader reader = new InputStreamReader(byteSource.openStream(), cs)) {
          CharStreams.copy(reader, sb);

  }

  /** Tests the various ways that the space character can be handled */
  public void testPlusForSpace() {
    UnicodeEscaper basicEscaper = new PercentEscaper("", false);
    UnicodeEscaper plusForSpaceEscaper = new PercentEscaper("", true);
    UnicodeEscaper spaceEscaper = new PercentEscaper(" ", false);

    assertEquals("string%20with%20spaces", basicEscaper.escape("string with spaces"));

        assertArrayEquals(new byte[0], lm);
        assertArrayEquals(new byte[0], nt);
    }

    @Test
    void unsupportedCredentialType() {
        assertThrows(SmbException.class, () -> new SmbComSessionSetupAndX(mockContext, mockNegotiate, mockAndX, "foo"));
    }

    @Test
    void byteArrayBlob() throws Exception {