type VersionFile struct {
	path string
}

func (v *VersionFile) nextPath() string {
	return fmt.Sprintf("%s-next", v.path)
}

// Exists returns true if a version.txt file exists on the file system.
func (v *VersionFile) Exists() (bool, error) {
	return exists(v.path)
}

// Read parses the version.txt file and returns it's contents.
func (v *VersionFile) Read() (*EtcdVersionPair, error) {

  <artifactId>aid</artifactId>
  <groupId>gid</groupId>
  <version>0.1</version>
  <packaging>pom</packaging>

  <profiles>
    <profile>
      <id>exists-basedir</id>
      <activation>
        <file>
          <exists>${basedir}/test.txt</exists>
        </file>
      </activation>
    </profile>
    <profile>
      <id>missing-basedir</id>
      <activation>
        <file>

        when:
        succeeds ':test'

        then:
        javaClassFile('module-info.class').exists()
        javaClassFile('consumer/MainModule.class').exists()
        classFile('java', 'test', 'consumer/test/MainModuleTest.class').exists()
    }

    def "runs whitebox test on module path by tweaking command line arguments"() {
        given:
        buildFile << """

		for name, quantity := range container.Resources.Requests {
			if !isSupportedQoSComputeResource(name) {
				continue
			}
			if quantity.Cmp(zeroQuantity) == 1 {
				delta := quantity.DeepCopy()
				if _, exists := requests[name]; !exists {
					requests[name] = delta
				} else {
					delta.Add(requests[name])
					requests[name] = delta
				}
			}
		}
		// process limits
		qosLimitsFound := sets.NewString()

        !fsBase.file("a").exists()
        !fsBase.file("a.fslock").exists()
    }

    def "can get from backing filestore"() {
        when:
        createFile("abc", "fs/a")
        then:
        store.get("a") != null
        store.get("b") == null
    }

    def "get cleans up filestore"() {
        when:
        createFile("abc", "fs/a").exists()

            assert file('foo').exists()
            assert file('bar').exists()
            assert file('baz').exists()

            task clean(type: Delete) {
                delete 'foo'
                delete file('bar')
                delete files('baz')
             }
        """

        when:
        succeeds "clean"

        then:
        !file('foo').exists()
        !file('bar').exists()

go test -cpuprofile errors.prof errors
exists -exec errors.test$GOEXE

# Check go test -cpuprofile -o myerrors.test creates errors.test
go test -cpuprofile errors.prof -o myerrors.test$GOEXE errors
exists -exec myerrors.test$GOEXE

# Check go test -mutexprofile creates errors.test
go test -mutexprofile errors.prof errors
exists -exec errors.test$GOEXE

	}
	// Sort for determinism.
	sort.StringSlice(selector).Sort()
	return strings.Join(selector, ",")
}

// Has returns whether the provided field exists in the map.
func (ls Set) Has(field string) bool {
	_, exists := ls[field]
	return exists
}

// Get returns the value in the map for the provided field.
func (ls Set) Get(field string) string {
	return ls[field]
}

! exists $GOPATH/pkg/mod/cache/download/rsc.io/quote/@v/v1.5.2.mod
! exists go.sum

# If go.sum exists but contains hashes from an algorithm we don't know about,
# we should see the same error.
cp go.sum.h2only go.sum
! go list -m all
stderr '^go: rsc.io/quote@v1.5.2: missing go.sum entry for go.mod file; to add it:\n\tgo mod download rsc.io/quote$'

package fdtest

import (
	"os"
	"runtime"
	"testing"
)

func TestExists(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("Exists not implemented for windows")
	}

	if !Exists(os.Stdout.Fd()) {
		t.Errorf("Exists(%d) got false want true", os.Stdout.Fd())
	}