//! Graph ownership, publication, and failure recovery tests.

use std::testing;

use std::lang::alloc;

/// Non-copy module state retained when graph construction is abandoned.

record ModuleState {

    /// Test value returned to the caller.

    value: u32,

}

/// Fallible construction state that owns module and graph state.

record Construction: 'g {

    /// Module state retained after graph abandonment.

    module: ModuleState,

    /// Graph authority consumed during abandonment.

    graph: super::Builder 'g,

}

/// Abandon graph construction and return the independent module state.

fn recoverModule 'g (state: Construction 'g) -> ModuleState {

    let case Construction 'g { module, graph } = state else panic;

    super::abandon(graph);

    return module;

}

/// Empty graphs can be published without node allocations.

@test fn testEmptyGraph() throws (testing::TestError) {

    static DATA: [u8; 64] = [0; 64];

    let mut arena = alloc::new(&mut DATA[..]);

    use arena as storage in {

        let builder = try! super::new(&storage);

        assert super::pending(&builder) == 0;

        let frozen = try! super::freeze(builder);

        assert super::len(&frozen) == 0;

    }

}

/// Node identities and completion counts survive repeated completion and freeze.

@test fn testNodeCompletion() throws (testing::TestError) {

    for count in [1 as u32, 2, 8, 64] {

        static DATA: [u8; 1024] = [0; 1024];

        let mut arena = alloc::new(&mut DATA[..]);

        use arena as storage in {

            let mut builder = try! super::new(&storage);

            let first = try! super::reserve(&mut builder, &storage);

            let mut nodes: [super::Node 'storage; 64] = [first; 64];

            for i in 1..count {

                set nodes[i] = try! super::reserve(&mut builder, &storage);

                for j in 0..i {

                    assert nodes[i] <> nodes[j];

                }

            }

            assert super::pending(&builder) == count;

            for i in 0..count {

                try! super::check(&builder, nodes[i]);

                try! super::complete(&mut builder, nodes[i]);

                assert super::pending(&builder) == count - i - 1;

                try! super::complete(&mut builder, nodes[i]);

                assert super::pending(&builder) == count - i - 1;

            }

            let frozen = try! super::freeze(builder);

            assert super::len(&frozen) == count;

            assert nodes[0] == first;

            for i in 0..count {

                try! super::checkFrozen(&frozen, nodes[i]);

            }

        }

    }

}

/// Builders in one session have separate ownership and completion authority.

@test fn testForeignNode() throws (testing::TestError) {

    static DATA: [u8; 128] = [0; 128];

    let mut arena = alloc::new(&mut DATA[..]);

    use arena as storage in {

        let mut first = try! super::new(&storage);

        let mut second = try! super::new(&storage);

        let a = try! super::reserve(&mut first, &storage);

        let b = try! super::reserve(&mut second, &storage);

        let mut rejected = false;

        try super::complete(&mut first, b) catch error {

            assert error == super::Error::ForeignNode;

            set rejected = true;

        };

        assert rejected;

        assert super::pending(&first) == 1;

        assert super::pending(&second) == 1;

        try! super::complete(&mut first, a);

        let frozen = try! super::freeze(first);

        set rejected = false;

        try super::checkFrozen(&frozen, b) catch error {

            assert error == super::Error::ForeignNode;

            set rejected = true;

        };

        assert rejected;

        try! super::complete(&mut second, b);

        let other = try! super::freeze(second);

        try! super::checkFrozen(&other, b);

    }

}

/// An incomplete freeze returns the sole builder for completion and retry.

@test fn testIncompleteFreezeRecovery() throws (testing::TestError) {

    static DATA: [u8; 128] = [0; 128];

    let mut arena = alloc::new(&mut DATA[..]);

    use arena as storage in {

        let mut builder = try! super::new(&storage);

        let first = try! super::reserve(&mut builder, &storage);

        let second = try! super::reserve(&mut builder, &storage);

        try! super::complete(&mut builder, first);

        try super::freeze(builder) catch error {

            let case super::FreezeError 'storage::Incomplete(recovered) = error else panic;

            let mut retry = recovered;

            assert super::pending(&retry) == 1;

            try! super::complete(&mut retry, second);

            let frozen = try! super::freeze(retry);

            assert super::len(&frozen) == 2;

            try! super::checkFrozen(&frozen, first);

            try! super::checkFrozen(&frozen, second);

            return;

        };

        throw testing::TestError::Failed;

    }

}

/// Abandoning any construction state leaves its allocation session usable.

@test fn testAbandon() throws (testing::TestError) {

    static DATA: [u8; 128] = [0; 128];

    let mut arena = alloc::new(&mut DATA[..]);

    use arena as storage in {

        let empty = try! super::new(&storage);

        super::abandon(empty);

        let mut incomplete = try! super::new(&storage);

        let abandonedNode = try! super::reserve(&mut incomplete, &storage);

        assert super::pending(&incomplete) == 1;

        super::abandon(incomplete);

        let fresh = try! super::new(&storage);

        let mut rejected = false;

        try super::check(&fresh, abandonedNode) catch error {

            assert error == super::Error::ForeignNode;

            set rejected = true;

        };

        assert rejected;

        super::abandon(fresh);

        let mut complete = try! super::new(&storage);

        let node = try! super::reserve(&mut complete, &storage);

        try! super::complete(&mut complete, node);

        assert super::pending(&complete) == 0;

        super::abandon(complete);

        let reusable = try! super::new(&storage);

        let frozen = try! super::freeze(reusable);

        assert super::len(&frozen) == 0;

        let graph = try! super::new(&storage);

        let module = recoverModule(Construction 'storage {

            module: ModuleState { value: 7 }, graph,

        });

        assert module.value == 7;

    }

}

/// Exhausted identity storage does not add incomplete nodes to the builder.

@test fn testAllocationFailure() throws (testing::TestError) {

    for capacity in 0..9 {

        static DATA: [u8; 16] = [0; 16];

        let mut arena = alloc::new(&mut DATA[..capacity]);

        use arena as storage in {

            if let created = try? super::new(&storage) {

                let mut builder = created;

                let mut count: u32 = 0;

                while let node = try? super::reserve(&mut builder, &storage) {

                    try! super::complete(&mut builder, node);

                    set count += 1;

                }

                assert super::pending(&builder) == 0;

                let frozen = try! super::freeze(builder);

                assert super::len(&frozen) == count;

                assert count == capacity - 1;

            } else {

                assert capacity == 0;

            }

        }

        assert alloc::used(&arena) == capacity;

    }

}