//skip all the tests in the file
                transformRestTests = transformer.transformRestTests(new LinkedList<>(tests),
                    Collections.singletonList(new Skip(skippedFilesWithReason.get(file))));
            } else {
                if (skippedFilesWithTestAndReason.containsKey(file)) {
                    //skip the named tests for this file

                /* The Elasticsearch test runner doesn't support quite a few
                 * constructs unless we output this skip. We don't know if
                 * we're going to use these constructs, but we might so we
                 * output the skip just in case. */
                current.println("  - skip:")
                current.println("      features: ")
                current.println("        - default_shards")

	skip := func(oi ObjectInfo) (ok bool) {
		if r.Flags.Filter.OlderThan > 0 && time.Since(oi.ModTime) < r.Flags.Filter.OlderThan.D() {
			// skip all objects that are newer than specified older duration
			return true
		}

		if r.Flags.Filter.NewerThan > 0 && time.Since(oi.ModTime) >= r.Flags.Filter.NewerThan.D() {
			// skip all objects that are older than specified newer duration

        source.skip(dashDashBoundary.size.toLong())
      } else {
        // This is a subsequent part or a preamble. Skip until "\r\n--" followed by the boundary.
        while (true) {
          val toSkip = currentPartBytesRemaining(maxByteCount = 8192)
          if (toSkip == 0L) break
          source.skip(toSkip)
        }
        source.skip(crlfDashDashBoundary.size.toLong())
      }

				// NOT an object, append to stack (with slash)
				// If dirObject, but no metadata (which is unexpected) we skip it.
				if !isDirObj {
					if !isDirEmpty(pathJoinBuf(sb, volumeDir, meta.name), legacyFS) {
						dirStack = append(dirStack, meta.name+slashSeparator)
					}
				}
			case isSysErrNotDir(err):
				// skip
			}
		}

		// If directory entry left on stack, pop it now.
		for len(dirStack) > 0 {

package clause

const (
	LockingStrengthUpdate    = "UPDATE"
	LockingStrengthShare     = "SHARE"
	LockingOptionsSkipLocked = "SKIP LOCKED"
	LockingOptionsNoWait     = "NOWAIT"
)

type Locking struct {
	Strength string
	Table    Table
	Options  string
}

// Name where clause name
func (locking Locking) Name() string {
	return "FOR"
}

// Build build where clause
func (locking Locking) Build(builder Builder) {

        request.setMatchWordFirst(matchWordFirst);
        return this;
    }

    /**
     * Sets whether to skip duplicate words.
     * @param skipDuplicateWords True to skip duplicate words, false otherwise.
     * @return This builder instance.
     */
    public SuggestRequestBuilder setSkipDuplicateWords(final boolean skipDuplicateWords) {

	if err != nil {
		return buf
	}
	if maj == 1 && minor < 1 {
		// First version to carry data.
		return buf
	}
	// Skip header
	_, metaBuf, err = msgp.ReadBytesZC(metaBuf)
	if err != nil {
		storageLogIf(GlobalContext, err)
		return buf
	}
	// Skip CRC
	if maj > 1 || minor >= 2 {
		_, metaBuf, err = msgp.ReadUint32Bytes(metaBuf)
		storageLogIf(GlobalContext, err)
	}

    assertEquals(3, uniqueEntries.size());
  }

  // Wrapper of EnumMultiset factory methods, because we need to skip create(Class).
  // create(Enum1.class) is equal to create(Enum2.class) but testEquals() expects otherwise.
  // For the same reason, we need to skip create(Iterable, Class).
  private static class EnumMultisetFactory {
    @Keep // used reflectively by testEquals

        session.addAssistantMessage("Assistant 2");
        session.addUserMessage("User 3");
        session.addAssistantMessage("Assistant 3");

        // Trimming to 4 starts at index 2 which is user - no skip needed
        session.trimHistory(4);

        final List<ChatMessage> messages = session.getMessages();
        assertEquals(4, messages.size());
        assertEquals(ChatMessage.ROLE_USER, messages.get(0).getRole());