}{
		// Invalid syntaxes
		{
			In:  `x`,
			Err: true,
		},
		{
			In:  ``,
			Err: true,
		},

		// Null
		{
			In:   `null`,
			Data: nil,
			Out:  `null`,
		},
		// Booleans
		{
			In:   `true`,
			Data: true,
			Out:  `true`,
		},
		{
			In:   `false`,
			Data: false,
			Out:  `false`,
		},

		// Integers
		{
			In:   `0`,
			Data: int64(0),

	// Value returns a driver Value.
	// Value must not panic.
	Value() (Value, error)
}

// Bool is a [ValueConverter] that converts input values to bool.
//
// The conversion rules are:
//   - booleans are returned unchanged
//   - for integer types,
//     1 is true
//     0 is false,
//     other integers are an error
//   - for strings and []byte, same rules as [strconv.ParseBool]
//   - all other types are an error

		istrue(z != iy)
		isfalse(x != iz)
		isfalse(z != ix)

		istrue(ix != y)
		istrue(iy != x)
		istrue(iy != z)
		istrue(iz != y)
		isfalse(ix != z)
		isfalse(iz != x)
	}

	// named booleans
	{
		type mybool bool
		var b mybool

		type T struct{ data [20]byte }
		var x, y T
		b = x == y
		istrue(x == y)
		istrue(bool(b))

		m := make(map[string][10]interface{})

Tom Tresansky <******@****.***> 1696954098 -0400

    public abstract boolean isIncludeVariants();
    public abstract boolean isIncludeRuleSchema();
    public abstract boolean isIncludeExtensions();
    public abstract boolean isIncludeExtensionsRecursively();

    public Optional<String> getSearchTarget() {
        return Optional.ofNullable(searchTarget);
    }
    public boolean isSearchForSpecificVariant() {
        return null != searchTarget;
    }

    private final List<ExcludeMetadata> excludes;
    private final List<IvyArtifactName> artifactNames;
    private final boolean force;
    private final boolean changing;
    private final boolean transitive;
    private final boolean constraint;
    private final boolean endorsing;
    private final boolean fromLock;
    private final String reason;

    public LocalComponentDependencyMetadata(
        ComponentSelector selector,

public class MinimalScalaCompileOptions implements Serializable {
    private boolean failOnError = true;
    private boolean deprecation = true;
    private boolean unchecked = true;
    private String debugLevel;
    private boolean optimize;
    private String encoding;
    private boolean force;
    private List<String> additionalParameters;
    private boolean listFiles;
    private String loggingLevel;

    private boolean configurationCacheDebug;
    private boolean configurationCacheIgnoreInputsInTaskGraphSerialization = false;
    private int configurationCacheMaxProblems = 512;
    private @Nullable String configurationCacheIgnoredFileSystemCheckInputs = null;
    private boolean configurationCacheRecreateCache;
    private boolean configurationCacheQuiet;
    private boolean searchUpwards = true;
    private boolean useEmptySettings = false;

    public BuildModelParameters(
        boolean parallelProjectExecution,
        boolean configureOnDemand,
        boolean configurationCache,
        boolean isolatedProjects,
        boolean requiresBuildModel,
        boolean intermediateModelCache,
        boolean parallelToolingApiActions,
        boolean invalidateCoupledProjects,
        boolean modelAsProjectDependency,
        LogLevel configurationCacheLogLevel

    @Nonnull
    Session getSession();

    @Nonnull
    Optional<Path> getPath();

    @Nonnull
    Optional<Source> getSource();

    boolean isAllowStubModel();

    boolean isRecursive();

    boolean isProcessPlugins();

    @Nonnull
    static ProjectBuilderRequest build(@Nonnull Session session, @Nonnull Source source) {
        return builder()