//! Tests for the bump allocator.

use std::testing;

/// Test basic allocation.

@test unsafe fn testAllocBasic() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    let ptr = try! super::alloc(&mut arena, 4, 4);

    try testing::expect(super::used(&arena) == 4);

    try testing::expect(super::remaining(&arena) == 60);

}

/// Test that allocations are properly aligned.

@test unsafe fn testAllocAlignment() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 1 byte with 1-byte alignment.

    let p1 = try! super::alloc(&mut arena, 1, 1);

    try testing::expect(super::used(&arena) == 1);

    // Allocate 4 bytes with 4-byte alignment - should pad to offset 4.

    let p2 = try! super::alloc(&mut arena, 4, 4);

    try testing::expect(super::used(&arena) == 8); // 1 + 3 padding + 4

}

/// Test multiple allocations.

@test unsafe fn testAllocMultiple() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    let p1 = try! super::alloc(&mut arena, 8, 4);

    let p2 = try! super::alloc(&mut arena, 16, 4);

    let p3 = try! super::alloc(&mut arena, 4, 4);

    try testing::expect(super::used(&arena) == 28); // 8 + 16 + 4

}

/// Test that arena throws when exhausted.

@test unsafe fn testAllocExhausted() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    // This should succeed.

    let p1 = try! super::alloc(&mut arena, 8, 4);

    // This should also succeed.

    let p2 = try! super::alloc(&mut arena, 8, 4);

    // Arena is now full, this should fail.

    let mut failed = false;

    try super::alloc(&mut arena, 1, 1) catch {

        set failed = true;

    };

    try testing::expect(failed);

}

/// Test that reset allows reuse of memory.

@test unsafe fn testAllocReset() throws (testing::TestError) {

    static STORAGE: [u8; 32] = [0; 32];

    let mut arena = super::new(&mut STORAGE[..]);

    let p1 = try! super::alloc(&mut arena, 16, 4);

    try testing::expect(super::used(&arena) == 16);

    super::reset(&mut arena);

    try testing::expect(super::used(&arena) == 0);

    try testing::expect(super::remaining(&arena) == 32);

    // Should be able to allocate again.

    let p2 = try! super::alloc(&mut arena, 32, 4);

}

/// Test alignment when offset is already aligned.

@test unsafe fn testAllocAlreadyAligned() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 4 bytes - offset becomes 4, already aligned for next 4-byte alloc.

    let p1 = try! super::alloc(&mut arena, 4, 4);

    try testing::expect(super::used(&arena) == 4);

    // Next 4-byte aligned allocation should not add padding.

    let p2 = try! super::alloc(&mut arena, 4, 4);

    try testing::expect(super::used(&arena) == 8);

}

/// Test allocation that would overflow with alignment padding.

@test unsafe fn testAllocOverflowWithPadding() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    // Allocate 1 byte, offset is now 1.

    let p1 = try! super::alloc(&mut arena, 1, 1);

    // Try to allocate 16 bytes with 4-byte alignment.

    // Aligned offset would be 4, then 4 + 16 = 20 > 16, so should fail.

    let mut failed = false;

    try super::alloc(&mut arena, 16, 4) catch {

        set failed = true;

    };

    try testing::expect(failed);

}

/// Test the Allocator interface backed by an arena.

@test unsafe fn testAllocator() throws (testing::TestError) {

    static STORAGE: [u8; 256] = [0; 256];

    let mut arena = super::new(&mut STORAGE[..]);

    let a = super::arenaAllocator(&mut arena);

    // Allocate through the Allocator indirection.

    let p1 = a.func(a.ctx, 16, 4);

    try testing::expect((p1 as u64 & 3) == 0);

    let p2 = a.func(a.ctx, 8, 8);

    try testing::expect((p2 as u64 & 7) == 0);

    try testing::expect(super::used(&arena) as u64 == p2 as u64 - &STORAGE[0] as u64 + 8);

    // Verify the pointers are distinct.

    try testing::expect(p1 as u64 <> p2 as u64);

}

/// Large counts and offsets must fail before arithmetic wraps or storage changes.

@test unsafe fn testAllocOverflow() throws (testing::TestError) {

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

    let mut arena = super::new(&mut bytes[..]);

    set arena.offset = 8;

    let mut failed: u32 = 0;

    try super::allocSlice(&mut arena, 8, 8, 0x20000000) catch {

        set failed += 1;

    };

    try super::alloc(&mut arena, 0xffffffff, 8) catch {

        set failed += 1;

    };

    try testing::expect(failed == 2 and arena.offset == 8);

    set arena.offset = 0xfffffff8;

    try super::alloc(&mut arena, 16, 16) catch {

        set failed += 1;

    };

    try testing::expect(failed == 3 and arena.offset == 0xfffffff8);

    set arena.offset = 8;

    let storage = try super::alloc(&mut arena, 8, 8) catch {

        throw testing::TestError::Failed;

    };

    try testing::expect((storage as u64 & 7) == 0);

    try testing::expect(arena.offset as u64 == storage as u64 - &bytes[0] as u64 + 8);

}

/// Allocation alignment uses the backing address and preserves distinct objects.

@test unsafe fn testAllocUnalignedBacking() throws (testing::TestError) {

    static STORAGE: [u8; 96] = [0; 96];

    for start in 0..16 {

        let mut arena = super::new(&mut STORAGE[start..]);

        let first = try! super::allocRaw(&mut arena, 8, 16) as *unsafe mut u64;

        set *first = 123;

        let second = try! super::allocRaw(&mut arena, 8, 16) as *unsafe mut u64;

        set *second = 456;

        try testing::expect((first as u64 & 15) == 0);

        try testing::expect((second as u64 & 15) == 0);

        try testing::expect(second as u64 >= first as u64 + 8);

        try testing::expect(*first == 123);

        try testing::expect(*second == 456);

    }

}

/// Capacity failure and arithmetic overflow leave the arena and live data intact.

@test unsafe fn testAllocFailureAtomicity() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    let first = try! super::allocRaw(&mut arena, 1, 1) as *unsafe mut u8;

    set *first = 42;

    for size in [64 as u32, 4294967295 as u32] {

        let saved = super::used(&arena);

        let mut failed = false;

        try super::alloc(&mut arena, size, 1) catch {

            set failed = true;

        };

        try testing::expect(failed);

        try testing::expect(super::used(&arena) == saved);

        try testing::expect(*first == 42);

    }

    let next = try! super::allocRaw(&mut arena, 1, 1) as *unsafe mut u8;

    try testing::expect(next as u64 == first as u64 + 1);

}

/// Slice count multiplication fails before either allocation API changes state.

@test unsafe fn testAllocSliceOverflowAtomicity() throws (testing::TestError) {

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

    let mut arena = super::new(&mut STORAGE[..]);

    let first = try! super::allocRaw(&mut arena, 1, 1) as *unsafe mut u8;

    set *first = 42;

    let saved = super::used(&arena);

    let mut failed = false;

    try super::allocSlice(&mut arena, 4, 4, 1073741825) catch {

        set failed = true;

    };

    try testing::expect(failed);

    try testing::expect(super::used(&arena) == saved);

    set failed = false;

    try super::allocRawSlice(&mut arena, 4, 4, 1073741825) catch {

        set failed = true;

    };

    try testing::expect(failed);

    try testing::expect(super::used(&arena) == saved);

    try testing::expect(*first == 42);

}