this(encode(flags));
    }


    /**
     * 
     * @return flags
     */
    public int getFlags () {
        return SMBUtil.readInt4(this.getRaw(), 0);
    }


    private static byte[] encode ( int flags ) {
        byte[] raw = new byte[4];
        SMBUtil.writeInt4(flags, raw, 0);
        return raw;
    }

package jcifs;


/**
 * Handle to an open file
 * 
 * @author mbechler
 *
 */
public interface SmbFileHandle extends AutoCloseable {

    /**
     * @return the tree
     */
    SmbTreeHandle getTree ();


    /**
     * @return whether the file descriptor is valid
     */
    boolean isValid ();


    /**
     * @param lastWriteTime
     * @throws CIFSException
     */

        super( req );
        this.principal = principal;
    }
    public String getRemoteUser() {
        return principal.getName();
    }
    public Principal getUserPrincipal() {
        return principal;
    }
    public String getAuthType() {
        return "NTLM";
    }

func (args *ReaderArgs) IsEmpty() bool {
	return !args.unmarshaled
}

// UnmarshalXML - decodes XML data.
func (args *ReaderArgs) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	// Make subtype to avoid recursive UnmarshalXML().
	type subReaderArgs ReaderArgs
	parsedArgs := subReaderArgs{}
	if err := d.DecodeElement(&parsedArgs, &start); err != nil {
		return err
	}

	args.unmarshaled = true
	return nil

	if osync {
		flags |= os.O_SYNC
	}
	appendFile, err := os.OpenFile(dst, flags, 0o666)
	if err != nil {
		return err
	}
	defer appendFile.Close()

	srcFile, err := os.Open(src)
	if err != nil {
		return err
	}
	defer srcFile.Close()
	_, err = io.Copy(appendFile, srcFile)
	return err

import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
import okhttp3.UrlComponentEncodingTester.Component

fun urlComponentEncodingTesterJvmPlatform(component: Component): UrlComponentEncodingTester.Platform {
  return when (component) {
    Component.USER ->
      UrlComponentEncodingTesterJvmPlatform()
        .escapeForUri('%'.code)

    Component.PASSWORD ->
      UrlComponentEncodingTesterJvmPlatform()

    assertNull(
        "putIfAbsent(notPresent, value) should return null", getMap().putIfAbsent(k3(), v3()));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(
        "putIfAbsent(present, value) should return existing value",
        v0(),
        getMap().putIfAbsent(k0(), v3()));

        }
        return indexName;
    }

    @Override
    protected LocalDateTime toLocalDateTime(final Object value) {
        if (value != null) {
            try {
                final Instant instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(value.toString()));
                return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());

            .createTestSuite());
    suite.addTestSuite(LinkedHashMultisetTest.class);
    return suite;
  }

  private static TestStringMultisetGenerator linkedHashMultisetGenerator() {
    return new TestStringMultisetGenerator() {
      @Override
      protected Multiset<String> create(String[] elements) {
        return LinkedHashMultiset.create(asList(elements));
      }

      @Override

    /**
     * Builds the effective toolchains for the specified toolchains files.
     *
     * @param request the toolchains building request that holds the parameters, must not be {@code null}
     * @return the result of the toolchains building, never {@code null}
     * @throws ToolchainsBuilderException if the effective toolchains could not be built
     */
    ToolchainsBuilderResult build(ToolchainsBuilderRequest request);