{@code META-INF/maven/lifecycle.xml} in a plugin's jar artifact.
  </description>
  <classes>
    <class rootElement="true" xml.tagName="lifecycles" xsd.compositor="sequence">
      <name>LifecycleConfiguration</name>
      <version>1.0.0+</version>
      <description>Root element of the {@code lifecycle.xml} file.</description>
      <fields>
        <field>

 *
 * @deprecated use {@code org.apache.maven.api.services.ModelBuilder} instead
 */
@Deprecated(since = "4.0.0")
public interface ModelBuildingResult {

    /**
     * Gets the sequence of model identifiers that denote the lineage of models from which the effective model was
     * constructed. Model identifiers have the form {@code <groupId>:<artifactId>:<version>}. The first identifier from

Requirements may be added, updated, and removed with 'go get'.
The vendor directory may be updated with 'go mod vendor'.
Tree inconsistencies are reported by 'go test cmd/internal/moddeps'.
A typical sequence might be:

    cd src  # or src/cmd
    go get golang.org/x/net@master
    go mod tidy
    go mod vendor
    go test cmd/internal/moddeps

Use caution when passing '-u' to 'go get'. The '-u' flag updates

		fmt.Fprintln(os.Stderr, "shouldn't see an error scanning a string")
	}
	// Output:
	// true
}

// Use a Scanner to implement a simple word-count utility by scanning the
// input as a sequence of space-delimited tokens.
func ExampleScanner_words() {
	// An artificial input source.
	const input = "Now is the winter of our discontent,\nMade glorious summer by this sun of York.\n"

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), null);

        // hasNext/next sequence over two elements
        assertTrue(it.hasNext(), "Expected first element available");
        SmbResource r1 = it.next();
        assertNotNull(r1);

			return
		case <-pingTimer:
			errState = !m.doPing(errResp)
		}
	}
}

// checkSeq will check if sequence number is correct and increment it by 1.
func (m *muxClient) checkSeq(seq uint32) (ok bool) {
	if seq != m.RecvSeq {
		if debugPrint {
			fmt.Printf("MuxID: %d client, expected sequence %d, got %d\n", m.MuxID, m.RecvSeq, seq)
		}
		m.addResponse(Response{Err: ErrIncorrectSequence})
		return false
	}

		}
	}
}

// Test that the rune splitter returns same sequence of runes (not bytes) as for range string.
func TestScanRune(t *testing.T) {
	for n, test := range scanTests {
		buf := strings.NewReader(test)
		s := NewScanner(buf)
		s.Split(ScanRunes)
		var i, runeCount int
		var expect rune
		// Use a string range loop to validate the sequence of runes.
		for i, expect = range test {
			if !s.Scan() {
				break

        this.data = data;
        this.dataOffset = offset;
        this.dataLength = length;
    }

    /**
     * Sets the number of bytes remaining to be written in a sequence of write operations.
     *
     * @param remainingBytes the remainingBytes to set
     */
    public void setRemainingBytes(final int remainingBytes) {
        this.remainingBytes = remainingBytes;
    }

    assertThrows(IndexOutOfBoundsException.class, () -> sink.putBytes(new byte[8], 0, -1));
  }

  /**
   * This test creates a long random sequence of inputs, then a lot of differently configured sinks
   * process it; all should produce the same answer, the only difference should be the number of
   * process()/processRemaining() invocations, due to alignment.
   */

   * i, i + target.length)} contains exactly the same elements as {@code target}.
   *
   * @param array the array to search for the sequence {@code target}
   * @param target the array to search for as a sub-sequence of {@code array}
   */
  public static int indexOf(byte[] array, byte[] target) {
    checkNotNull(array, "array");
    checkNotNull(target, "target");