//! returns: 0
//! Test basic opaque pointer usage (automatic coercion).
unsafe fn testOpaqueCasting() -> bool {
    let x: u32 = 42;
    let ptr: *unsafe u8 = &x as *unsafe u8;
    let opq: *unsafe opaque = ptr;  // Automatic coercion from *u8 to *opaque.
    let back: *unsafe u8 = opq as *unsafe u8;

    return back == ptr;
}

/// Test that opaque can be used in function parameters.
unsafe fn takesOpaque(ptr: *unsafe opaque, orig: *unsafe u8) -> bool {
    let back: *unsafe u8 = ptr as *unsafe u8;
    return back == orig;
}

unsafe fn testOpaqueParams() -> bool {
    let x: u32 = 42;
    let ptr: *unsafe u8 = &x as *unsafe u8;
    return takesOpaque(ptr, ptr);  // Automatic coercion in function call.
}

/// Test that opaque can be used in return types.
fn returnsOpaque(ptr: *unsafe u8) -> *unsafe opaque {
    return ptr;  // Automatic coercion in return.
}

unsafe fn testOpaqueReturn() -> bool {
    let x: u32 = 42;
    let ptr: *unsafe u8 = &x as *unsafe u8;
    let opq: *unsafe opaque = returnsOpaque(ptr);
    return opq as *unsafe u8 == ptr;
}

/// Test nullable opaque pointers.
unsafe fn testNullableOpaque() -> bool {
    let mut opt: ?*unsafe opaque = nil;
    if opt == nil {
        let x: u32 = 42;
        let ptr: *unsafe u8 = &x as *unsafe u8;
        set opt = ptr;  // Automatic coercion in assignment.

        if let p = opt {
            return p as *unsafe u8 == ptr;
        }
    }
    return false;
}

@default unsafe fn main() -> u32 {
    assert testOpaqueCasting();
    assert testOpaqueParams();
    assert testOpaqueReturn();
    assert testNullableOpaque();
    return 0;
}