// Check pattern is well-formed.
	if _, err := path.Match(pattern, ""); err != nil {
		return nil, err
	}
	if !hasMeta(pattern) {
		if _, err = Stat(fsys, pattern); err != nil {
			return nil, nil
		}
		return []string{pattern}, nil
	}

	dir, file := path.Split(pattern)
	dir = cleanGlobPath(dir)

	if !hasMeta(dir) {
		return glob(fsys, dir, file, nil)
	}

	// Prevent infinite recursion. See issue 15879.

		return nil, err
	}
	if !hasMeta(pattern) {
		if _, err = os.Lstat(pattern); err != nil {
			return nil, nil
		}
		return []string{pattern}, nil
	}

	dir, file := Split(pattern)
	volumeLen := 0
	if runtime.GOOS == "windows" {
		volumeLen, dir = cleanGlobPathWindows(dir)
	} else {
		dir = cleanGlobPath(dir)
	}

	if !hasMeta(dir[volumeLen:]) {
		return glob(dir, file, nil)
	}

		return nil, err
	}
	if !hasMeta(pattern) {
		if _, err = Lstat(pattern); err != nil {
			return nil, nil
		}
		return []string{pattern}, nil
	}

	dir, file := filepath.Split(pattern)
	volumeLen := 0
	if runtime.GOOS == "windows" {
		volumeLen, dir = cleanGlobPathWindows(dir)
	} else {
		dir = cleanGlobPath(dir)
	}

	if !hasMeta(dir[volumeLen:]) {
		return glob(dir, file, nil)

    }

    default boolean hasData(MeasuredOperationList measuredOperations) {
        return !measuredOperations.getTotalTime().isEmpty();
    }

    default ExecutionGraph toExecutionGraph(PerformanceTestExecution execution, int index) {
        Line baseline = new Line(execution.getScenarios().stream().filter(this::hasData).findFirst().orElse(new MeasuredOperationList()));

		}
	}

	// Write out the length of the data.
	if spec.HasData {
		w.buf = binary.AppendUvarint(w.buf, uint64(len(e.Data)))
	}

	// Write out varint events.
	_, err := w.w.Write(w.buf)
	w.buf = w.buf[:0]
	if err != nil {
		return err
	}

	// Write out data.
	if spec.HasData {
		_, err := w.w.Write(e.Data)
		return err
	}
	return nil

	// otherwise aren't actually surfaced by the trace reader.
	IsTimedEvent bool

	// HasData is true if the event has trailer consisting of a
	// varint length followed by unencoded bytes of some data.
	//
	// An event may not be both a timed event and have data.
	HasData bool

	// IsStack indicates that the event represents a complete
	// stack trace. Specifically, it means that after the arguments

                        .setStandardInput("hasta la vista $idx")

                    assert model.get().description == "hasta la vista $idx"

                    assert operation.standardOutput.contains("out=hasta la vista $idx")
                    assert operation.standardOutput.count("out=hasta la vista") == 1

                    assert operation.standardError.contains("err=hasta la vista $idx")

	case *pe.OptionalHeader32:
		dc = oh.DllCharacteristics
	case *pe.OptionalHeader64:
		dc = oh.DllCharacteristics
		hasHEVA := (dc & pe.IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA) != 0
		if useASLR && !hasHEVA {
			t.Error("IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA flag is not set")
		} else if !useASLR && hasHEVA {
			t.Error("IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA flag should not be set")
		}
	default:

    int getCount(String sessionId);

    void delete(String sessionId);

    void deleteAll();

    RESULT getAccessResult(String sessionId, String url);

    List<RESULT> getAccessResultList(String url, boolean hasData);

    void iterate(String sessionId, final AccessResultCallback<RESULT> accessResultCallback);

        when:
        def serializer = new SetSerializer(stringSerializer)

        then:
        serialize(["one", null, "three"] as Set, serializer) as List == ["one", null, "three"]
    }

    def "serializes with HasSet"() {
        when:
        def serializer = new SetSerializer(stringSerializer, false)

        then:
        serialize(['1', '2'] as Set, serializer) instanceof HashSet
    }