*x = 1;
}

void setintptr(intptr x) {
	*x = 1;
}

void setvoidptr(void *x) {
	*(int*)x = 1;
}

typedef struct Struct Struct;
struct Struct {
	int *P;
};

void setstruct(Struct s) {
	*s.P = 1;
}

// issue 11925
// Structs with zero-length trailing fields are now padded by the Go compiler.

struct a11925 {
	int i;
	char a[0];
	char b[0];
};

type marshalWithParamsTest struct {
	in     any
	params string
	out    string // hex encoded
}

var marshalWithParamsTests = []marshalWithParamsTest{
	{intStruct{10}, "set", "310302010a"},
	{intStruct{10}, "application", "600302010a"},
	{intStruct{10}, "private", "e00302010a"},
}

func TestMarshalWithParams(t *testing.T) {
	for i, test := range marshalWithParamsTests {

	}
}

func TestIsValueFuncs(t *testing.T) {
	testInt := int(42)
	testStruct := struct{}{}
	testSlice := []bool{}
	testMap := map[bool]bool{}
	var testNilSlice []bool
	var testNilMap map[bool]bool

	allValues := []any{nil, testInt, &testInt, testStruct, &testStruct, testNilSlice, testSlice, &testSlice, testNilMap, testMap, &testMap}

	tests := []struct {
		desc     string

		t.Errorf("got %v, wanted {'Test': 12u, 'Check': 34u}", mpStrUint)
	}
	tstStr, err := mv.ConvertToNative(reflect.TypeOf(&tstStruct{}))
	if err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(tstStr, &tstStruct{
		Test:  uint64(12),
		Check: uint64(34),
	}) {
		t.Errorf("got %v, wanted tstStruct{Test: 12u, Check: 34u}", tstStr)
	}
}

func TestMapValueEqual(t *testing.T) {
	mv := NewMapValue()

func messageToStruct(t *testing.T, m proto.Message) *structpb.Struct {
	st, err := conversion.MessageToStruct(m)
	if err != nil {
		t.Fatal(err)
	}
	return st
}

func newStruct(t *testing.T, m map[string]any) *structpb.Struct {
	st, err := structpb.NewStruct(m)
	if err != nil {
		t.Fatal(err)
	}
	return st
}

func messageToAnyWithTypeURL(t *testing.T, msg proto.Message, typeURL string) *anypb.Any {

			expr = cond
		} else {
			expr = ir.NewLogicalExpr(base.Pos, andor, expr, cond)
		}
	}
	cmpl = safeExpr(cmpl, init)
	cmpr = safeExpr(cmpr, init)
	if t.IsStruct() {
		conds, _ := compare.EqStruct(t, cmpl, cmpr)
		if n.Op() == ir.OEQ {
			for _, cond := range conds {
				and(cond)
			}
		} else {
			for _, cond := range conds {
				notCond := ir.NewUnaryExpr(base.Pos, ir.ONOT, cond)

	T1 := NewNamed(n1, nil, nil)
	n2 := NewTypeName(nopos, nil, "T2", nil)
	T2 := NewNamed(n2, nil, nil)
	s1 := NewStruct([]*Var{NewField(nopos, nil, "_", T2, false)}, nil)
	T1.SetUnderlying(s1)
	s2 := NewStruct([]*Var{NewField(nopos, nil, "_", T2, false)}, nil)
	s3 := NewStruct([]*Var{NewField(nopos, nil, "_", s2, false)}, nil)
	T2.SetUnderlying(s3)

	// These calls must terminate (no endless recursion).

            result.setRoomNumber(DfTypeUtil.toString(source.get("roomNumber")));
            result.setState(DfTypeUtil.toString(source.get("state")));
            result.setStreet(DfTypeUtil.toString(source.get("street")));
            result.setSurname(DfTypeUtil.toString(source.get("surname")));
            result.setTelephoneNumber(DfTypeUtil.toString(source.get("telephoneNumber")));

	stringStruct := struct{ F string }{"foo"}
	fmt.Printf("%s", &stringStruct) // not an error

	intStruct := struct{ F int }{3}
	fmt.Printf("%s", &intStruct) // ERROR "Printf format %s has arg &intStruct of wrong type \*struct{F int}"

	stringMap := map[string]string{"foo": "bar"}
	fmt.Printf("%s", &stringMap) // not an error

	intMap := map[int]int{3: 4}

        this.state = value;
    }

    public String getStreet() {
        checkSpecifiedProperty("street");
        return convertEmptyToNull(street);
    }

    public void setStreet(String value) {
        registerModifiedProperty("street");
        this.street = value;
    }

    public String getSurname() {
        checkSpecifiedProperty("surname");