//! Test result-based error handling with try/throw.

union TestError { Boom, Bust }

record ResultSink {

    last: u32,

    count: u32,

}

fn returnsOk() -> u32 throws (TestError) {

    return 21;

}

fn returnsErr(kind: u32) -> u32 throws (TestError) {

    if kind == 0 {

        throw TestError::Boom;

    }

    if kind == 1 {

        throw TestError::Bust;

    }

    return 9;

}

fn returnsOkVoid() throws (TestError) {}

fn returnsErrVoid() throws (TestError) {

    throw TestError::Bust;

}

fn sumThree() -> u32 throws (TestError) {

    let a: u32 = try returnsOk();

    let b: u32 = try returnsErr(2);

    let c: u32 = try returnsErr(2);

    return a + b + c;

}

fn shortCircuit(flag: bool) -> u32 throws (TestError) {

    let mut counter: u32 = 1;

    if flag {

        counter += try returnsErr(2);

    } else {

        try returnsErr(0);

        counter += 100;

    }

    return counter;

}

fn aggregateTwo() -> u32 throws (TestError) {

    return (try returnsOk()) + (try returnsErr(2));

}

fn cascade(flag: bool) -> u32 throws (TestError) {

    let base: u32 = try returnsOk();

    if flag {

        try returnsErr(1);

    }

    return base + 1;

}

fn directThrow() -> u32 throws (TestError) {

    throw TestError::Boom;

    return 999;

}

fn maybeReturn(fail: bool) -> u32 throws (TestError) {

    if fail {

        throw TestError::Bust;

    }

    return 77;

}

fn catchReturn(flag: *mut u32, fail: bool) -> bool {

    let value: u32 = try maybeReturn(fail) catch {

        return true;

    };

    *flag = value;

    return false;

}

fn accumulateSteps(failMid: bool) -> u32 throws (TestError) {

    let mut total: u32 = 0;

    let mut idx: u32 = 0;

    while idx < 3 {

        if failMid {

            if idx == 1 {

                total += try returnsErr(0);

            } else {

                total += try returnsErr(2);

            }

        } else {

            total += try returnsErr(2);

        }

        idx += 1;

    }

    return total;

}

fn structSuccess(state: *mut ResultSink) -> u32 throws (TestError) {

    let value: u32 = try returnsOk();

    state.last = value;

    state.count += 1;

    return value;

}

fn structFailure(state: *mut ResultSink) -> u32 throws (TestError) {

    try returnsErr(1);

    state.last = 999;

    return 999;

}

@default fn main() -> i32 {

    let mut sumFlag: u32 = 0;

    let total: u32 = try! sumThree();

    assert total == 39;

    sumFlag = total;

    let mut scOkFlag: u32 = 0;

    let scVal: u32 = try! shortCircuit(true);

    assert scVal == 10;

    scOkFlag = scVal;

    let mut scErrFlag: u32 = 0;

    try shortCircuit(false) catch {};

    assert scErrFlag == 0;

    let mut aggFlag: u32 = 0;

    let aggVal: u32 = try! aggregateTwo();

    assert aggVal == 30;

    let mut casOkFlag: u32 = 0;

    let casVal: u32 = try! cascade(false);

    assert casVal == 22;

    let mut casErrFlag: u32 = 0;

    try cascade(true) catch {};

    assert casErrFlag == 0;

    let mut loopOkFlag: u32 = 0;

    let loopVal: u32 = try! accumulateSteps(false);

    assert loopVal == 27;

    let mut loopErrFlag: u32 = 0;

    try accumulateSteps(true) catch {};

    assert loopErrFlag == 0;

    let mut sink: ResultSink = ResultSink { last: 0, count: 0 };

    let sVal: u32 = try! structSuccess(&mut sink);

    assert sink.last == 21;

    assert sink.count == 1;

    try structFailure(&mut sink) catch {};

    try! structSuccess(&mut sink);

    try structFailure(&mut sink) catch {};

    assert sink.count == 2;

    let mut voidOkFlag: u32 = 0;

    try! returnsOkVoid();

    voidOkFlag = 77;

    assert voidOkFlag == 77;

    let mut voidErrFlag: u32 = 0;

    try returnsErrVoid() catch {};

    assert voidErrFlag == 0;

    let result: ?u32 = try? directThrow();

    assert result == nil;

    let mut catchReturnFlag: u32 = 0;

    let catchReturnFail: bool = catchReturn(&mut catchReturnFlag, true);

    assert catchReturnFail;

    assert catchReturnFlag == 0;

    let catchReturnOk: bool = catchReturn(&mut catchReturnFlag, false);

    assert not catchReturnOk;

    assert catchReturnFlag == 77;

    return 0;

}