//! Kernel resource management and machine execution.

use std::testing;

export mod range;

@test export mod tests;

//! Checked half-open ranges for physical memory and CPU windows.

/// A nonempty half-open interval. Construct intervals with `new`.

export record Range: Copy {

    /// First included address or tick.

    start: u64,

    /// First excluded address or tick.

    end: u64,

}

/// Construct a nonempty interval. Reject addition overflow.

export fn new(start: u64, length: u64) -> ?Range {

    if length == 0 or length > 0xffffffffffffffff - start {

        return nil;

    }

    return Range { start, end: start + length };

}

/// Check that the complete nonempty interval is inside the outer interval.

export fn contains(outer: Range, inner: Range) -> bool {

    return outer.start <= inner.start and inner.start < inner.end and inner.end <= outer.end;

}

//! Kernel unit tests. Machine execution tests have separate entry points.

export mod range;

//! Bounds and overflow checks for kernel intervals.

use kernel::range;

use std::testing;

/// Check empty intervals and overflow at the address-space boundary.

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

    try testing::expect(range::new(0, 0) == nil);

    try testing::expect(range::new(0xffffffffffffffff, 1) == nil);

    try testing::expect(range::new(1, 0xffffffffffffffff) == nil);

    let span = range::new(0, 0xffffffffffffffff) else {

        throw testing::TestError::Failed;

    };

    try testing::expect(span.start == 0);

    try testing::expect(span.end == 0xffffffffffffffff);

}

/// Check exact bounds, partial overlap, and the excluded upper bound.

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

    let outer = range::Range { start: 4096, end: 8192 };

    try testing::expect(range::contains(outer, outer));

    try testing::expect(range::contains(outer, range::Range { start: 4097, end: 8191 }));

    try testing::expect(not range::contains(outer, range::Range { start: 4095, end: 4097 }));

    try testing::expect(not range::contains(outer, range::Range { start: 8191, end: 8193 }));

    try testing::expect(not range::contains(outer, range::Range { start: 8192, end: 8193 }));

    try testing::expect(not range::contains(outer, range::Range { start: 4096, end: 4096 }));

}