}
  }

  public void testPutStringWithLowSurrogate() {
    // we pad because the dummy hash function we use to test this, merely copies the input into
    // the output, so the input must be at least 32 bits, since the output has to be that long
    assertPutString(new char[] {'p', HashTestUtils.randomLowSurrogate(new Random())});
  }

  public void testPutStringWithHighSurrogate() {

 *
 */
public class LongConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToLong() throws Exception {
        assertEquals(Long.valueOf("1000"), LongConversionUtil.toLong("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveLong() throws Exception {
        assertEquals(1000, LongConversionUtil.toPrimitiveLong("1,000"));
    }

    /**

 * https://github.com/google/guava/issues/3990
 */
@GwtIncompatible
final class Java8Compatibility {
  static void clear(Buffer b) {
    b.clear();
  }

  static void flip(Buffer b) {
    b.flip();
  }

  static void limit(Buffer b, int limit) {
    b.limit(limit);
  }

  static void position(Buffer b, int position) {
    b.position(position);
  }

  private Java8Compatibility() {}

    @Mock
    private ToolchainFactory toolchainFactoryBasicType;

    @Mock
    private ToolchainFactory toolchainFactoryRareType;

    @Mock
    private Lookup lookup;

    @BeforeEach
    void onSetup() throws Exception {
        MockitoAnnotations.initMocks(this);

        Map<String, ToolchainFactory> factories = new HashMap<>();
        factories.put("basic", toolchainFactoryBasicType);

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachKnownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    getMap().forEach((k, v) -> entries.add(entry(k, v)));
    assertEquals(getOrderedElements(), entries);
  }

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testForEachUnknownOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();

    private static final class WsrClassCatcher extends AbstractMavenLifecycleParticipant {
        private final AtomicReference<Class<?>> wsrClassRef = new AtomicReference<>(null);

        @Override
        public void afterProjectsRead(MavenSession session) throws MavenExecutionException {
            wsrClassRef.set(session.getRepositorySession().getWorkspaceReader().getClass());
        }
    }

    @Inject
    private Maven maven;

        if (ctxOffsetFromHeader != null && ctxBytes != null) {
            System.arraycopy(ctxBytes, 0, packet, ctxOffsetFromHeader, ctxBytes.length);
        }
        return packet;
    }

    @Test
    void decode_basic_noContexts() throws Exception {
        Configuration config = Mockito.mock(Configuration.class);
        Smb2CreateResponse resp = new Smb2CreateResponse(config, "file.txt");

        return challenge;
    }

    /**
     * Sets the challenge for this message.
     *
     * @param challenge The challenge from the domain controller/server.
     */
    public void setChallenge(final byte[] challenge) {
        this.challenge = challenge;
    }

    /**
     * Returns the authentication target.
     *

    void getTreeId_noTree_returnsMinusOne() {
        // Arrange
        CIFSContext ctx = mock(CIFSContext.class);
        SmbTreeConnectionTrace trace = new SmbTreeConnectionTrace(ctx);

        // Act & Assert
        assertEquals(-1L, trace.getTreeId());
    }

    @Test
    @DisplayName("getConfig(): delegates to context")
    void getConfig_delegatesToContext() {

                + "]";
    }

    void setUid(int uid) {
        this.uid = uid;
    }

    void setSessionSetup(Smb2SessionSetupResponse response) {
        this.extendedSecurity = true;
        this.connectionState.set(2);
        this.sessionId = response.getSessionId();
    }

    void setSessionSetup(SmbComSessionSetupAndXResponse response) {