'''
        file('a/src/main/resources/A.properties') << '''
            aprop=avalue
        '''

        file('b/src/main/java/B.java') << '''
            public class B {
                public int truth() { return 0; }
            }
        '''
        file('b/src/main/resources/B.properties') << '''
            bprop=bvalue
        '''
    }

internal
class OverlayRoutedValueDataContainer<DValue, DValueFactory : DValue, DLiteral : DValue>(
    private val overlayOriginContainer: OverlayOriginContainer,
    private val underlay: ValueDataContainer<DValue, DValueFactory, DLiteral>,
    private val overlay: ValueDataContainer<DValue, DValueFactory, DLiteral>
) : ValueDataContainer<DValue, DValueFactory, DLiteral> {

    }

    public void setBusinessCategory_GreaterThan(String businessCategory, ConditionOptionCall<RangeQueryBuilder> opLambda) {
        final Object _value = businessCategory;
        RangeQueryBuilder builder = regRangeQ("businessCategory", ConditionKey.CK_GREATER_THAN, _value);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

package atomic

import (
	"unsafe"
)

// A Value provides an atomic load and store of a consistently typed value.
// The zero value for a Value returns nil from [Value.Load].
// Once [Value.Store] has been called, a Value must not be copied.
//
// A Value must not be copied after first use.
type Value struct {
	v any
}

// efaceWords is interface{} internal representation.

func FromBool(b bool) *Value {
	return &Value{value: b}
}

// FromTimestamp creates a Value from a timestamp
func FromTimestamp(t time.Time) *Value {
	return &Value{value: t}
}

// FromNull creates a Value with Null value
func FromNull() *Value {
	return &Value{value: nil}
}

// FromMissing creates a Value with Missing value
func FromMissing() *Value {
	return &Value{value: Missing{}}
}

        setBoost_GreaterThan(boost, null);
    }

    public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
        final Object _value = boost;
        RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, _value);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setBoost_LessThan(Float boost) {

    }

    public void setAccessType_GreaterThan(String accessType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
        final Object _value = accessType;
        RangeQueryBuilder builder = regRangeQ("accessType", ConditionKey.CK_GREATER_THAN, _value);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setAccessType_LessThan(String accessType) {

	"reflect"
)

func main() {
	a := arena.NewArena()
	defer a.Free()

	const iValue = 10

	i := arena.New[int](a)
	*i = iValue

	if *i != iValue {
		// This test doesn't reasonably expect this to fail. It's more likely
		// that *i crashes for some reason. Still, why not check it.
		log.Fatalf("bad i value: got %d, want %d", *i, iValue)
	}

	const wantLen = 125
	const wantCap = 1912

    }

    public void setGidNumber_GreaterThan(Long gidNumber, ConditionOptionCall<RangeQueryBuilder> opLambda) {
        final Object _value = gidNumber;
        RangeQueryBuilder builder = regRangeQ("gidNumber", ConditionKey.CK_GREATER_THAN, _value);
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

    public void setGidNumber_LessThan(Long gidNumber) {

interface ValueDataContainer<DValue, DValueFactory : DValue, DLiteral : DValue> {
    fun data(value: DeclarativeDocument.ValueNode): DValue = when (value) {
        is DeclarativeDocument.ValueNode.ValueFactoryNode -> data(value)
        is DeclarativeDocument.ValueNode.LiteralValueNode -> data(value)
    }

    fun data(value: DeclarativeDocument.ValueNode.ValueFactoryNode): DValueFactory