cd broken_no_matching_files
! go mod vendor
stderr '^go: resolving embeds in example.com/brokendep: pattern foo.txt: no matching files found$'
go mod vendor -e
stderr '^go: resolving embeds in example.com/brokendep: pattern foo.txt: no matching files found$'

cd ../broken_bad_pattern
! go mod vendor
stderr '^go: resolving embeds in example.com/brokendep: pattern ../foo.txt: invalid pattern syntax$'

    }

    /**
     * Uses the git diff algorithm for presenting matches.
     * <p>
     * Enabling this option will only show a single match, regardless of how many potential matches
     * containing the same number of matching lines are found.
     *
     * @return searcher that uses a unified diff output
     */
    public static ExhaustiveLinesSearcher useUnifiedDiff() {
        return new ExhaustiveLinesSearcher(true);
    }

			t.Errorf("nil filter chain %d", i)
			continue
		}
		if fc.FilterChainMatch.TransportProtocol == "" && fc.FilterChainMatch.GetDestinationPort().GetValue() != 15006 {
			// Not setting transport protocol may lead to unexpected matching behavior due to https://github.com/istio/istio/issues/26079
			// This is not *always* a bug, just a guideline - the 15006 blocker filter chain doesn't follow this rule and is exluced.

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// As of "Mon 6 Nov 2017", run.go doesn't yet have proper
// column matching so instead match the output manually
// by exec-ing

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"strings"
)

func main() {

 * limitations under the License.
 */

package org.gradle.caching.example;

import com.google.common.collect.ImmutableMap;
import com.google.inject.Guice;
import com.google.inject.Inject;
import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.internal.CacheableEntity;
import org.gradle.caching.internal.SimpleBuildCacheKey;
import org.gradle.caching.internal.controller.BuildCacheController;

	if !SourceDA.IsValid() && !SourceDB.IsValid() {
		return false // "equal"
	}
	if !SourceDB.IsValid() {
		return preferDA
	}
	if !SourceDA.IsValid() {
		return preferDB
	}

	// Rule 2: Prefer matching scope.
	// If Scope(DA) = Scope(Source(DA)) and Scope(DB) <> Scope(Source(DB)),
	// then prefer DA.  Similarly, if Scope(DA) <> Scope(Source(DA)) and
	// Scope(DB) = Scope(Source(DB)), then prefer DB.

        }

        expect:
        assertDoesNotMatch(JvmVendorSpec.IBM, metadata)
        assertDoesNotMatch(JvmVendorSpec.AMAZON, metadata)
        assertMatches(JvmVendorSpec.matching("customjdk"), metadata)
    }

    void assertMatches(JvmVendorSpec spec, actualToolchain) {
        assert ((Predicate<JavaToolchain>) spec).test(actualToolchain)
    }

     * dependency will update the version of any dependency with matching GAV.
     * (Same goes for <type> on optional dependencies: they are effectively ignored).
     *
     * Note that this doesn't really match with Maven, where an optional dependency with classifier will
     * provide a version for any other dependency with matching GAV + classifier.
     */

)

// lookup determines the type of block n and looks up the value for b.
// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
// is a list of ranges with an accompanying value. Given a matching range r,
// the value for b is by r.value + (b - r.lo) * stride.
func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
	offset := t.offset[n]
	header := t.values[offset]
	lo := offset + 1
	hi := lo + uint16(header.lo)

====
include::sample[dir="snippets/buildCache/caching-android-projects/kotlin",files="build.gradle.kts[tags=cacheKapt]"]
include::sample[dir="snippets/buildCache/caching-android-projects/groovy",files="build.gradle[tags=cacheKapt]"]
====

== Unit test execution