labels.hostname	=	Nom d'hôte
labels.id	=	IDENTIFIANT
labels.includedPaths	=	Chemins inclus pour l'exploration
labels.includedUrls	=	URL incluses pour l'exploration
labels.includedDocPaths	=	Chemins inclus pour l'indexation
labels.includedDocUrls	=	URL incluses pour l'indexation
labels.maxAccessCount	=	Nombre d'accès maximum
labels.name	=	Nom
labels.numOfThread	=	Nombre de Thread
labels.duplicateHostName	=	Nom en double

// used for multi-destination targets
func (d Destination) TargetArn() bool {
	return strings.HasPrefix(d.ARN, DestinationARNMinIOPrefix)
}

// MarshalXML - encodes to XML data.
func (d Destination) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if err := e.EncodeToken(start); err != nil {
		return err
	}

	// * an error on failure of unlock request operation.
	ForceUnlock(ctx context.Context, args LockArgs) (bool, error)

	// Returns underlying endpoint of this lock client instance.
	String() string

	// Close closes any underlying connection to the service endpoint
	Close() error

	// Is the underlying connection online? (is always true for any local lockers)
	IsOnline() bool

	// Is the underlying locker local to this server?

            boolean exclusive, boolean forceSigning );


    /**
     * 
     * @param trans
     */
    void removeTransport ( SmbTransport trans );


    /**
     * Closes the pool and all connections in it
     * 
     * @return whether any transport was still in use
     * 
     * @throws CIFSException
     * 
     */
    boolean close () throws CIFSException;

    if (eventSequence.isEmpty()) {
      assertThat(e).isInstanceOf(ConnectionEvent.ConnectStart::class.java)
    } else {
      eventSequence.forEach loop@{
        when (e.closes(it)) {
          null -> return // no open event
          true -> return // found open event
          false -> return@loop // this is not the open event so continue
        }
      }

	Not   bool     `parser:" @\"NOT\"? "`
	Start *Operand `parser:" \"BETWEEN\" @@ "`
	End   *Operand `parser:" \"AND\" @@ "`
}

// In represents the RHS of an IN expression. The RHS can be a list-literal
// (i.e. enclosed in parentheses like `IN (1,2,4)`) or it could be a JSON path
// expression (as in `8.5 IN s.nested[*][*]`). Specifically, it cannot be an
// `Expression` as an expression can never evaluate to a list.
type In struct {

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "{}"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the

        this.dataLength = len;
        this.digest = null; /*
                             * otherwise recycled commands
                             * like writeandx will choke if session
                             * closes in between
                             */
    }


    /**
     * @param writeMode
     *            the writeMode to set
     */
    public final void setWriteMode ( int writeMode ) {

        "text <code>text</code>" | "<p>text <code>text</code></p>"
        "<ul>text</ul>"          | "<ul><p>text</p></ul>"
    }

    def "closes implicit <p> element at start of block element"() {
        expect:
        parse(source) == transformed

        where:
        source              | transformed
        "text<p>para 2</p>" | "<p>text</p><p>para 2</p>"

import java.util.Deque;
import java.util.logging.Level;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;

/**
 * A {@link Closeable} that collects {@code Closeable} resources and closes them all when it is
 * {@linkplain #close closed}. This was intended to approximately emulate the behavior of Java 7's
 * <a href="http://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html"