interface Animal {
mut:
    breed string
}

struct Cat {
    padding int // ensures that the field offsets can be different
mut:
    breed string
}

struct Dog {
    padding  [256]u8
    padding2 int
mut:
    breed string
}

fn use_interface(a Animal) {
    assert a.breed in ['Persian', 'Labrador']
    if a is Cat {
        assert a.breed == 'Persian'
    } else {
        assert a.breed == 'Labrador'
    }
}

fn mutate_interface(mut a Animal) {
    if mut a is Cat {
        a.breed = 'Siamese'
    } else {
        a.breed = 'Golden Retriever'
    }
    if mut a is Cat {
        assert a.breed == 'Siamese'
    } else {
        assert a.breed == 'Golden Retriever'
    }
    a.breed = 'what??'
    assert a.breed == 'what??'
}

fn test_interface_fields() {
    mut c := Cat{
        breed: 'Persian'
    }
    mut d := Dog{
        breed: 'Labrador'
    }
    use_interface(c)
    use_interface(d)
    mutate_interface(mut c)
    mutate_interface(mut d)
    assert c.breed == 'what??'
    assert d.breed == 'what??'
}

struct Nofun {
    foo fn (int) int
}

interface NofunInterface {
    foo fn (int) int
}

fn my_fn(a int) int {
    assert a == 123
    return a * 2
}

fn test_interface_fn_pointer_fields() {
    nf := NofunInterface(Nofun{my_fn})
    assert nf.foo(123) == 246
}

// For issue: 16198 errors when the reference interface type field of the struct is nil(init, assign...)
interface Speaker {
    speak() string
}

struct Wolf {}

fn (w Wolf) speak() string {
    return 'woof'
}

struct Foo {
mut:
    speaker &Speaker = unsafe { nil }
}

fn test_set_nil_to_ref_interface_type_fields() {
    mut foo := Foo{
        speaker: unsafe { nil }
    }
    assert true

    foo.speaker = unsafe { nil }
    assert true

    foo.speaker = &Wolf{}
    assert foo.speaker.speak() == 'woof'
}