// Host with root path -> possibleNTDomainOrWorkgroup=true
        UniAddress a2 = mock(UniAddress.class);
        UniAddress a3 = mock(UniAddress.class);
        when(nsc.getAllByName("server", true)).thenReturn(new Address[] { a2, a3 });
        SmbResourceLocatorImpl l3 = locator("smb://server/");
        assertSame(a2, l3.getAddress());
        verify(nsc, times(1)).getAllByName("server", true);
        assertTrue(l3.hasNextAddress());

    boolean USE_UNICODE = Config.getBoolean("jcifs.smb1.smb.client.useUnicode", true);
    /** Whether to force Unicode usage */
    boolean FORCE_UNICODE = Config.getBoolean("jcifs.smb1.smb.client.useUnicode", false);
    /** Whether to use NT status codes */
    boolean USE_NTSTATUS = Config.getBoolean("jcifs.smb1.smb.client.useNtStatus", true);
    /** Whether signing is preferred */

                }
            }
        } finally {
            zip.close()
        }
        true
    }

    private static boolean assertDefaultDirPermissions(int mode) {
        assert ((mode >> 6) & 07) == 7
        assert ((mode >> 3) & 07) == 5
        assert ((mode >> 0) & 07) == 5
        true
    }

    private static boolean assertDefaultFilePermissions(int mode) {

    }

  /** Returns true if [certificate] matches [ipAddress]. */
  private fun verifyIpAddress(
    ipAddress: String,
    certificate: X509Certificate,
  ): Boolean {
    val canonicalIpAddress = ipAddress.toCanonicalHost()

    return getSubjectAltNames(certificate, ALT_IPA_NAME).any {
      canonicalIpAddress == it.toCanonicalHost()
    }
  }

  /** Returns true if [certificate] matches [hostname]. */

            infoLevel.setAccessible(true);
            assertEquals(Trans2QueryPathInformationResponse.SMB_QUERY_FILE_BASIC_INFO, infoLevel.getInt(resp));

            // Verify subCommand is set correctly
            Field subCmd = SmbComTransactionResponse.class.getDeclaredField("subCommand");
            subCmd.setAccessible(true);

        TestAuthenticationChain chain2 = new TestAuthenticationChain();
        TestAuthenticationChain chain3 = new TestAuthenticationChain();
        chain1.changePasswordResult = true;
        chain2.changePasswordResult = true;
        chain3.changePasswordResult = true;

        authenticationManager.addChain(chain1);
        authenticationManager.addChain(chain2);
        authenticationManager.addChain(chain3);

          when {
            fieldName.equals("Date", ignoreCase = true) -> {
              servedDate = value.toHttpDateOrNull()
              servedDateString = value
            }

            fieldName.equals("Expires", ignoreCase = true) -> {
              expires = value.toHttpDateOrNull()
            }

            fieldName.equals("Last-Modified", ignoreCase = true) -> {
              lastModified = value.toHttpDateOrNull()

      return true
    }

    if (nextRouteToTry != null) {
      return true
    }

    if (failedConnection != null) {
      val retryRoute = retryRoute(failedConnection)
      if (retryRoute != null) {
        // Lock in the route because retryRoute() is racy and we don't want to call it twice.
        nextRouteToTry = retryRoute
        return true
      }
    }

   *
   * @return true if the range of [string] from [pos] to [limit] was valid and decoded successfully.
   *     Otherwise, the decode failed.
   */
  private fun decodeLabel(
    string: String,
    pos: Int,
    limit: Int,
    result: Buffer,
  ): Boolean {
    if (!string.regionMatches(pos, PREFIX_STRING, 0, 4, ignoreCase = true)) {
      result.writeUtf8(string, pos, limit)

      assertFalse(runCalled);
      assertFalse(shutDownCalled);
      startUpCalled = true;
      assertEquals(State.STARTING, state());
    }

    @Override
    protected void run() {
      assertTrue(startUpCalled);
      assertFalse(runCalled);
      assertFalse(shutDownCalled);
      runCalled = true;
      assertEquals(State.RUNNING, state());

      enterRun.countDown();
      try {