//! Tests for the bump allocator.

use std::testing;

/// Test basic allocation.

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

    static STORAGE: [u8; 64] = undefined;

    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 fn testAllocAlignment() throws (testing::TestError) {

    static STORAGE: [u8; 64] = undefined;

    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 fn testAllocMultiple() throws (testing::TestError) {

    static STORAGE: [u8; 128] = undefined;

    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 fn testAllocExhausted() throws (testing::TestError) {

    static STORAGE: [u8; 16] = undefined;

    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 fn testAllocReset() throws (testing::TestError) {

    static STORAGE: [u8; 32] = undefined;

    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 fn testAllocAlreadyAligned() throws (testing::TestError) {

    static STORAGE: [u8; 64] = undefined;

    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 fn testAllocOverflowWithPadding() throws (testing::TestError) {

    static STORAGE: [u8; 16] = undefined;

    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 that a forged arena offset cannot wrap allocation arithmetic.

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

    static STORAGE: [u8; 16] = undefined;

    let mut arena = super::Arena { data: &mut STORAGE[..], offset: 0xFFFFFFFF };

    let mut failed = false;

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

        set failed = true;

    };

    try testing::expect(failed);

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

}

/// Test that slice byte extents cannot overflow u32.

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

    static STORAGE: [u8; 16] = undefined;

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

    let count: u32 = 0xFFFFFFFF / 3 + 1;

    let mut failed = false;

    try super::allocSlice(&mut arena, 3, 1, count) catch {

        set failed = true;

    };

    try testing::expect(failed);

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

}

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

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

    static STORAGE: [u8; 256] = undefined;

    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(super::used(&arena) == 16);

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

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

    // Verify the pointers are distinct.

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

}