zig/test/cases/math.zig
2017-01-05 03:57:48 -05:00

180 lines
3.7 KiB
Zig

const assert = @import("std").debug.assert;
fn exactDivision() {
@setFnTest(this);
assert(divExact(55, 11) == 5);
}
fn divExact(a: u32, b: u32) -> u32 {
@divExact(a, b)
}
fn floatDivision() {
@setFnTest(this);
assert(fdiv32(12.0, 3.0) == 4.0);
}
fn fdiv32(a: f32, b: f32) -> f32 {
a / b
}
fn overflowIntrinsics() {
@setFnTest(this);
var result: u8 = undefined;
assert(@addWithOverflow(u8, 250, 100, &result));
assert(!@addWithOverflow(u8, 100, 150, &result));
assert(result == 250);
}
fn shlWithOverflow() {
@setFnTest(this);
var result: u16 = undefined;
assert(@shlWithOverflow(u16, 0b0010111111111111, 3, &result));
assert(!@shlWithOverflow(u16, 0b0010111111111111, 2, &result));
assert(result == 0b1011111111111100);
}
fn countLeadingZeroes() {
@setFnTest(this);
assert(@clz(u8(0b00001010)) == 4);
assert(@clz(u8(0b10001010)) == 0);
assert(@clz(u8(0b00000000)) == 8);
}
fn countTrailingZeroes() {
@setFnTest(this);
assert(@ctz(u8(0b10100000)) == 5);
assert(@ctz(u8(0b10001010)) == 1);
assert(@ctz(u8(0b00000000)) == 8);
}
fn modifyOperators() {
@setFnTest(this);
var i : i32 = 0;
i += 5; assert(i == 5);
i -= 2; assert(i == 3);
i *= 20; assert(i == 60);
i /= 3; assert(i == 20);
i %= 11; assert(i == 9);
i <<= 1; assert(i == 18);
i >>= 2; assert(i == 4);
i = 6;
i &= 5; assert(i == 4);
i ^= 6; assert(i == 2);
i = 6;
i |= 3; assert(i == 7);
}
fn threeExprInARow() {
@setFnTest(this);
assertFalse(false || false || false);
assertFalse(true && true && false);
assertFalse(1 | 2 | 4 != 7);
assertFalse(3 ^ 6 ^ 8 != 13);
assertFalse(7 & 14 & 28 != 4);
assertFalse(9 << 1 << 2 != 9 << 3);
assertFalse(90 >> 1 >> 2 != 90 >> 3);
assertFalse(100 - 1 + 1000 != 1099);
assertFalse(5 * 4 / 2 % 3 != 1);
assertFalse(i32(i32(5)) != 5);
assertFalse(!!false);
assertFalse(i32(7) != --(i32(7)));
}
fn assertFalse(b: bool) {
assert(!b);
}
fn constNumberLiteral() {
@setFnTest(this);
const one = 1;
const eleven = ten + one;
assert(eleven == 11);
}
const ten = 10;
fn unsignedWrapping() {
@setFnTest(this);
testUnsignedWrappingEval(@maxValue(u32));
}
fn testUnsignedWrappingEval(x: u32) {
const zero = x +% 1;
assert(zero == 0);
const orig = zero -% 1;
assert(orig == @maxValue(u32));
}
fn signedWrapping() {
@setFnTest(this);
testSignedWrappingEval(@maxValue(i32));
}
fn testSignedWrappingEval(x: i32) {
const min_val = x +% 1;
assert(min_val == @minValue(i32));
const max_val = min_val -% 1;
assert(max_val == @maxValue(i32));
}
fn negationWrapping() {
@setFnTest(this);
testNegationWrappingEval(@minValue(i16));
}
fn testNegationWrappingEval(x: i16) {
assert(x == -32768);
const neg = -%x;
assert(neg == -32768);
}
fn shlWrapping() {
@setFnTest(this);
testShlWrappingEval(@maxValue(u16));
}
fn testShlWrappingEval(x: u16) {
const shifted = x <<% 1;
assert(shifted == 65534);
}
fn unsigned64BitDivision() {
@setFnTest(this);
const result = div(1152921504606846976, 34359738365);
assert(result.quotient == 33554432);
assert(result.remainder == 100663296);
}
fn div(a: u64, b: u64) -> DivResult {
DivResult {
.quotient = a / b,
.remainder = a % b,
}
}
const DivResult = struct {
quotient: u64,
remainder: u64,
};
fn binaryNot() {
@setFnTest(this);
assert(@staticEval(~u16(0b1010101010101010) == 0b0101010101010101));
assert(@staticEval(~u64(2147483647) == 18446744071562067968));
testBinaryNot(0b1010101010101010);
}
fn testBinaryNot(x: u16) {
assert(~x == 0b0101010101010101);
}