}

    def "gets overloaded methods from a single type"() {
        expect:
        def overloaded = ModelSchemaUtils.getCandidateMethods(TypeWithOverloadedMethods).overloadedMethodsNamed("someOverloadedMethod")
        overloaded.size() == 2
        overloaded.values()[0]*.name == ["someOverloadedMethod"]
        overloaded.values()[1]*.name == ["someOverloadedMethod"]
    }

            "output", staleFileAddedBetweenExecutions
        )

        when:
        def overlaps = detector.detect(previousOutputFiles, outputFilesBeforeExecution)

        then:
        overlaps.propertyName == "output"
        overlaps.overlappedFilePath == "/absolute/path"
    }

    def "detects overlap when there is a stale #type in an output directory"() {

# Test listing with overlays

# Overlay in an existing directory
go list -overlay overlay.json  -f '{{.GoFiles}}' .
stdout '^\[f.go\]$'

# Overlays in a non-existing directory
go list -overlay overlay.json -f '{{.GoFiles}}' ./dir
stdout '^\[g.go\]$'

# Overlays in an existing directory with already existing files
go list -overlay overlay.json -f '{{.GoFiles}}' ./dir2
stdout '^\[h.go i.go\]$'

# Overlay that removes a file from a directory

// STL-style container class, the first overload of IsContainerTest
// will be viable (since both C::iterator* and C::const_iterator* are
// valid types and NULL can be implicitly converted to them).  It will
// be picked over the second overload as 'int' is a perfect match for
// the type of argument 0.  If C::iterator or C::const_iterator is not
// a valid type, the first overload is not viable, and the second

  @Override
  <T extends @Nullable Object> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
      throws InterruptedException;

  /**
   * Duration-based overload of {@link #invokeAll(Collection, long, TimeUnit)}.
   *
   * @since 32.1.0
   */
  @J2ktIncompatible
  default <T extends @Nullable Object> List<Future<T>> invokeAll(

		{"/a/{m...}", "/a/b/{y...}", moreGeneral},
		{"/a/{m...}", "/a/{x}/{y...}", moreGeneral},
		{"/a/{z}/{m...}", "/a/b/{y...}", moreGeneral},
		{"/a/{z}/{m...}", "/{z}/a/", overlaps},
		{"/a/{z}/{m...}", "/{z}/b/{y...}", overlaps},
		{"/a/{z}/b/{m...}", "/{x}/c/{y...}", overlaps},
		{"/a/{z}/a/{m...}", "/{x}/b", disjoint},

		// Dollar on left.
		{"/{$}", "/a", disjoint},
		{"/{$}", "/a/b", disjoint},
		{"/{$}", "/{$}", equivalent},

	tests := []struct {
		name     string
		overlays []string
		wantErr  bool
		stdin    bool
	}{
		{
			name:     "layer1",
			overlays: []string{"yaml_layer1"},
			wantErr:  false,
		},
		{
			name:     "layer1_stdin",
			overlays: []string{"yaml_layer1"},
			wantErr:  false,
			stdin:    true,
		},
		{
			name:     "layer1_2",
			overlays: []string{"yaml_layer1", "yaml_layer2"},
			wantErr:  false,

				Rules: []batch.SuccessPolicyRule{{
					SucceededIndexes: ptr.To("10-12,14-16"),
				}},
			},
		},
		"rules.succeededIndexes is specified; succeededIndexes didn't match rules; rules overlaps succeededIndexes at first": {
			enableJobSuccessPolicy: true,
			completions:            10,
			succeededIndexes:       orderedIntervals{{2, 4}, {6, 8}},
			successPolicy: &batch.SuccessPolicy{

	return Mask(m.Mask())
}

// Contains returns whether *all* flags in other is present in t.
func (t Mask) Contains(other Mask) bool {
	return t&other == other
}

// Overlaps returns whether *any* flags in t overlaps with other.
func (t Mask) Overlaps(other Mask) bool {
	return t&other != 0
}

// SingleType returns whether t has a single type set.
func (t Mask) SingleType() bool {
	return bits.OnesCount64(uint64(t)) == 1
}

				},
			},
			attributes:           endpointCreateAttributes(),
			expression:           "variables.name == 'endpoints1'",
			expectErr:            true,
			expectedErrorMessage: `found no matching overload for '_==_' applied to '(int, string)'`,
		},
		{
			name: "delayed eval error",
			variables: []NamedExpressionAccessor{
				&testVariable{
					name:       "count",