def "serializes exception when dependencies aren't resolved"() {
        when:
        file('build.gradle') << """
dependencies {
    ${implementationConfiguration} 'commons-lang:commons-lang:10.0-NOTEXISTS'
}
"""
        def customModel = withConnection { connection ->
            connection.model(CustomArtifactModel).get()
        }
        def failure = customModel.failure

        then:

            throw new ThemeException("Theme name is empty: " + artifact);
        }
        return themeName;
    }

    protected void closeQuietly(final Path dir) {
        if (Files.notExists(dir)) {
            if (logger.isDebugEnabled()) {
                logger.debug("{} does not exists.", dir);
            }
            return;
        }

		return s
	}
	return ""
}

func TestErrIsNotExist(t *testing.T) {
	tmpDir := t.TempDir()
	name := filepath.Join(tmpDir, "NotExists")
	if s := testErrNotExist(t, name); s != "" {
		t.Fatal(s)
	}

	name = filepath.Join(name, "NotExists2")
	if s := testErrNotExist(t, name); s != "" {
		t.Fatal(s)
	}
}

        Path path,
        @VarargParameter LinkOption[] options,
        @CallerClassName String consumer
    ) {
        tryReportFileSystemEntryObserved(path, consumer);
        return Files.notExists(path, options);
    }

    // TODO: handle varargs in Groovy
    @InterceptCalls
    @StaticMethod(ofClass = Files.class)
    public static SeekableByteChannel intercept_newByteChannel(
        Path path,

		v, err := i.findValue(path)
		if err != nil {
			return err
		}
		if v == nil {
			return fmt.Errorf("no entry exists at path: %v", path)
		}
		return nil
	})
}

func (i *Instance) NotExists(path string, args ...any) *Instance {
	path = fmt.Sprintf(path, args...)
	return i.appendConstraint(func() error {
		parser := jsonpath.New("path")
		err := parser.Parse(i.fixPath(path))
		if err != nil {

		validator := structpath.ForProto(cfg)
		for _, port := range dest.Config().Ports {
			clusterName := clusterName(dest, port)
			// Ensure that we have an outbound configuration for the target port.
			err := validator.NotExists("{.configs[*].dynamicActiveClusters[?(@.cluster.Name == '%s')]}", clusterName).Check()
			if err != nil {
				return false, err
			}
		}

		return true, nil
	}

	workloads, _ := c.Workloads()

	labelSelector := MakeLabelSelector().Exists(labelKey).Obj()
	p.PodAntiAffinity(topologyKey, labelSelector, kind)
	return p
}

// PodAffinityNotExists creates a PodAffinity with the operator "NotExists"
// and injects into the inner pod.
func (p *PodWrapper) PodAffinityNotExists(labelKey, topologyKey string, kind PodAffinityKind) *PodWrapper {
	labelSelector := MakeLabelSelector().NotExist(labelKey).Obj()

		"NotCupCap;":                       '\U0000226D',
		"NotDoubleVerticalBar;":            '\U00002226',
		"NotElement;":                      '\U00002209',
		"NotEqual;":                        '\U00002260',
		"NotExists;":                       '\U00002204',
		"NotGreater;":                      '\U0000226F',
		"NotGreaterEqual;":                 '\U00002271',
		"NotGreaterLess;":                  '\U00002279',

	"∦":            "\u2226",
	"∉":                      "\u2209",
	"≠":                        "\u2260",
	"≂̸":                   "\u2242\u0338",
	"∄":                       "\u2204",
	"≯":                      "\u226f",
	"≱":                 "\u2271",
	"≧̸":             "\u2267\u0338",