if (config.getMinimumVersion().isSMB2()) {
            this.dialects = new String[] { "SMB 2.???", "SMB 2.002" };
        } else if (config.getMaximumVersion().isSMB2()) {
            this.dialects = new String[] { "NT LM 0.12", "SMB 2.???", "SMB 2.002" };
        } else {
            this.dialects = new String[] { "NT LM 0.12" };
        }
    }

    /**
     * {@inheritDoc}
     *

    T getContent();

    @Nullable
    Function<Object, String> getInputLocationFormatter();

    static <T> XmlWriterRequestBuilder<T> builder() {
        return new XmlWriterRequestBuilder<>();
    }

    class XmlWriterRequestBuilder<T> {
        Path path;
        OutputStream outputStream;
        Writer writer;
        T content;
        Function<Object, String> inputLocationFormatter;

     */
    public netdfs() {
        // Default constructor
    }

    /**
     * Gets the DCE/RPC syntax identifier for the DFS interface
     * @return the syntax identifier string
     */
    public static String getSyntax() {
        return "4fc742e0-4a10-11cf-8273-00aa004ae673:3.0";
    }

    /**
     * DFS volume flavor indicating standalone DFS
     */

    val requestA = builder.tag(String::class.java, "a").build()
    val requestB = builder.tag(String::class.java, "b").build()
    val requestC = requestA.newBuilder().tag(String::class.java, "c").build()
    assertThat(requestA.tag(String::class.java)).isSameInstanceAs("a")
    assertThat(requestB.tag(String::class.java)).isSameInstanceAs("b")
    assertThat(requestC.tag(String::class.java)).isSameInstanceAs("c")
  }

  }

  @SuppressWarnings("OptionalOfRedundantMethod") // Unit tests for Optional
  public void testOr_nullSupplier_present() {
    Supplier<String> nullSupplier = (Supplier<String>) Suppliers.<@Nullable String>ofInstance(null);
    assertThat(Optional.of("a").or(nullSupplier)).isEqualTo("a");
  }

  @SuppressWarnings("OptionalOfRedundantMethod") // Unit tests for Optional

		t.Fatal(err)
	}
	// Failure case where we detected successfully cross device mounts.
	{
		absPaths := []string{"/path/to/1"}
		if err = checkCrossDevice(absPaths, mountsPath); err == nil {
			t.Fatal("Expected to fail, but found success")
		}

		mp := []mountInfo{
			{"/dev/2", "/path/to/1/2", "type2", []string{"flags"}, "2", "2"},
		}

  @AndroidIncompatible // test-suite builders
  public static class ImmutableEnumMapGenerator extends TestEnumMapGenerator {
    @Override
    protected Map<AnEnum, String> create(Entry<AnEnum, String>[] entries) {
      Map<AnEnum, String> map = new HashMap<>();
      for (Entry<AnEnum, String> entry : entries) {
        map.put(entry.getKey(), entry.getValue());
      }
      return immutableEnumMap(map);
    }
  }

  @J2ktIncompatible

        for (ObjectNode test : tests) {
            Iterator<Map.Entry<String, JsonNode>> testsIterator = test.fields();
            while (testsIterator.hasNext()) {
                Map.Entry<String, JsonNode> testObject = testsIterator.next();
                String testName = testObject.getKey();
                if ("setup".equals(testName)) {
                    setupSection = test;

  )
  val utf8Body: String
    get() = body.readUtf8()

  val tlsVersion: TlsVersion?
    get() = handshake?.tlsVersion

  internal constructor(
    requestLine: String,
    headers: Headers,
    chunkSizes: List<Int>,
    bodySize: Long,
    body: Buffer,
    sequenceNumber: Int,
    failure: IOException?,
    method: String?,
    path: String?,
    handshake: Handshake?,

                            .toArray(n -> new String[n])));
            entity.setPermissions(encodePermissions(form.permissions));
            entity.setVirtualHosts(split(form.virtualHosts, "\n")
                    .get(stream -> stream.filter(StringUtil::isNotBlank).distinct().map(String::trim).toArray(n -> new String[n])));
            return entity;
        });
    }

    /**