//! returns: 0
//! Test slice capacity field and @sliceOf builtin.

@default unsafe fn main() -> i32 {
    // Test that regular slices have cap == len.
    let mut arr: [i32; 4] = [10, 20, 30, 40];
    let s: *unsafe mut [i32] = &mut arr[..];

    if s.cap <> 4 {
        return 1;
    }
    if s.len <> s.cap {
        return 2;
    }

    // Test @sliceOf with explicit capacity.
    let ptr: *unsafe mut i32 = &mut arr[0];
    let s2 = @sliceOf(ptr, 2, 4);

    if s2.len <> 2 {
        return 3;
    }
    if s2.cap <> 4 {
        return 4;
    }
    if s2[0] <> 10 {
        return 5;
    }
    if s2[1] <> 20 {
        return 6;
    }

    // Test @sliceOf with zero length.
    let s3 = @sliceOf(ptr, 0, 4);

    if s3.len <> 0 {
        return 7;
    }
    if s3.cap <> 4 {
        return 8;
    }

    // Test @sliceOf still works and has cap == len.
    let s4 = @sliceOf(ptr, 3);

    if s4.len <> 3 {
        return 9;
    }
    if s4.cap <> 3 {
        return 10;
    }
    return 0;
}