# prior to the fix for that issue, it occasionally failed with ETXTBSY when
# run on Unix platforms.

go test -c -o $WORK/some/nonexisting/directory/ ./pkg/...
exists -exec $WORK/some/nonexisting/directory/pkg1.test$GOEXE
exists -exec $WORK/some/nonexisting/directory/pkg2.test$GOEXE

go test -c ./pkg/...
exists -exec pkg1.test$GOEXE
exists -exec pkg2.test$GOEXE

	tests := []struct {
		name     string
		paths    []string
		expected bool
	}{
		{
			name: "non-existing cert paths",
			paths: []string{
				"/this-is-a-nonexisting-path-1", "/this-is-a-nonexisting-path-2",
				"/this-is-a-nonexisting-path-3",
			},
			expected: false,
		},
		{
			name:     "existing cert paths",
			paths:    []string{cert.Name(), cert.Name(), cert.Name()},
			expected: true,
		},
		{

        withSettings(
            """
            val nonExisting: String by settings
            println(nonExisting)
            """
        )

        assertThat(
            buildAndFail("help").error,
            containsString("Cannot get non-null property 'nonExisting' on settings '${projectRoot.name}' as it does not exist")
        )

        withSettings("")

	}{
		{
			// question mark syntax still requires the field to exist in object construction
			name: "construct non-existing field, compile error",
			expression: `Object{
				?nonExisting: optional.none()
			}`,
			expectedCompileError: `undefined field 'nonExisting'`,
		},
		{
			// The root cause of the behavior above is that, has on an object (or Message in the Language Def),
			// still require the field to be declared in the schema.

// except treating "nonExisting" field as non-existing.
// This is used for optional tests.
type mockTypeRefForOptional struct {
	common.TypeRef
}

// Field returns a mock FieldType, or false if the field should not exist.
func (m *mockTypeRefForOptional) Field(name string) (*types.FieldType, bool) {
	if name == "nonExisting" {
		return nil, false
	}
	return m.TypeRef.Field(name)
}

		{
			Name:                 "nonexisting group discovery, presync",
			Method:               "GET",
			Path:                 "/apis/other",
			APIGroup:             "other",
			APIVersion:           "",
			HasSynced:            false,
			IsResourceRequest:    false,
			ExpectDelegateCalled: true,
			ExpectStatus:         503,
		},
		{
			Name:                 "nonexisting group discovery",

				},
				{
					Expression: "object.spec.replicas > '1' && object.spec.nonExisting == 1",
				},
			}, makePolicy("confused-deployment"))),
			assertFieldRef: toBe("spec.validations[1].expression"),
			assertWarnings: toHaveMultipleSubstrings([]string{"undefined field 'nonExisting'", `found no matching overload for '_>_' applied to '(int, string)'`}),
		},
	} {
		t.Run(tc.name, func(t *testing.T) {

				Variables: []v1.Variable{
					{
						Name:       "works",
						Expression: "true",
					},
				},
				Validations: []v1.Validation{
					{
						Expression: "variables.nonExisting",
					},
				},
				MatchConstraints: deploymentPolicy.Spec.MatchConstraints,
			},
			},
			schemaToReturn: &spec.Schema{
				SchemaProps: spec.SchemaProps{
					Type: []string{"object"},

        def dir = temporaryFolder.createDir("some/dir")
        def existingFileInDir = dir.file("someFile.txt").createFile()
        def nonExistingFileInDir = dir.file("subdir/nonExisting.txt")

        when:
        allowFileSystemAccess(true)
        def snapshot = read(dir)
        then:
        assertIsDirectorySnapshot(snapshot, dir)

			for _, n := range allNodes {
				if n.Name == test.nodeToUpdate.Name {
					oldNode = n
					break
				}
			}
			if oldNode == nil {
				oldNode = &v1.Node{ObjectMeta: metav1.ObjectMeta{Name: "nonexisting-node"}}
			}
			nt.updateNode(logger, oldNode, test.nodeToUpdate)
			verifyNodeTree(t, nt, test.expectedTree)
		})
	}
}

func TestNodeTree_List(t *testing.T) {
	tests := []struct {