UpsilonNumworks/Upsilon
1
0
Fork 0
mirror of https://github.com/UpsilonNumworks/Upsilon.git synced 2026-01-18 16:27:34 +01:00
Code Issues Packages Projects Releases Wiki Activity

[quiz] Turn all assert in quiz_assert

Browse Source
This commit is contained in:
Émilie Feral
2018-08-28 10:40:52 +02:00
parent d3296be915
commit a1bcbe28e6
29 changed files with 261 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
liba/test/aeabi.c
View File

@@ -6,37 +6,37 @@ long long __aeabi_llsl(long long value, int shift);
long long __aeabi_llsr(long long value, int shift);
QUIZ_CASE(liba_llsl) {
assert(__aeabi_llsl((uint64_t)1, 1) == (uint64_t)0x2);
assert(__aeabi_llsl((uint64_t)1, 2) == (uint64_t)0x4);
assert(__aeabi_llsl((uint64_t)1, 10) == (uint64_t)0x400);
assert(__aeabi_llsl((uint64_t)1, 20) == (uint64_t)0x100000);
assert(__aeabi_llsl((uint64_t)1, 30) == (uint64_t)0x40000000);
assert(__aeabi_llsl((uint64_t)1, 31) == (uint64_t)0x80000000);
assert(__aeabi_llsl((uint64_t)1, 32) == (uint64_t)0x100000000);
assert(__aeabi_llsl((uint64_t)1, 33) == (uint64_t)0x200000000);
assert(__aeabi_llsl((uint64_t)1, 40) == (uint64_t)0x10000000000);
assert(__aeabi_llsl((uint64_t)1, 50) == (uint64_t)0x4000000000000);
assert(__aeabi_llsl((uint64_t)1, 60) == (uint64_t)0x1000000000000000);
assert(__aeabi_llsl((uint64_t)1, 61) == (uint64_t)0x2000000000000000);
assert(__aeabi_llsl((uint64_t)1, 62) == (uint64_t)0x4000000000000000);
assert(__aeabi_llsl((uint64_t)1, 63) == (uint64_t)0x8000000000000000);
assert(__aeabi_llsl((uint64_t)1, 64) == (uint64_t)0);
quiz_assert(__aeabi_llsl((uint64_t)1, 1) == (uint64_t)0x2);
quiz_assert(__aeabi_llsl((uint64_t)1, 2) == (uint64_t)0x4);
quiz_assert(__aeabi_llsl((uint64_t)1, 10) == (uint64_t)0x400);
quiz_assert(__aeabi_llsl((uint64_t)1, 20) == (uint64_t)0x100000);
quiz_assert(__aeabi_llsl((uint64_t)1, 30) == (uint64_t)0x40000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 31) == (uint64_t)0x80000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 32) == (uint64_t)0x100000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 33) == (uint64_t)0x200000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 40) == (uint64_t)0x10000000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 50) == (uint64_t)0x4000000000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 60) == (uint64_t)0x1000000000000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 61) == (uint64_t)0x2000000000000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 62) == (uint64_t)0x4000000000000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 63) == (uint64_t)0x8000000000000000);
quiz_assert(__aeabi_llsl((uint64_t)1, 64) == (uint64_t)0);
}
QUIZ_CASE(liba_llsr) {
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 1) == (uint64_t)0x4000000000000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 2) == (uint64_t)0x2000000000000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 10) == (uint64_t)0x20000000000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 20) == (uint64_t)0x80000000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 30) == (uint64_t)0x200000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 31) == (uint64_t)0x100000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 32) == (uint64_t)0x80000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 33) == (uint64_t)0x40000000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 40) == (uint64_t)0x800000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 50) == (uint64_t)0x2000);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 60) == (uint64_t)0x8);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 61) == (uint64_t)0x4);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 62) == (uint64_t)0x2);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 63) == (uint64_t)0x1);
assert(__aeabi_llsr((uint64_t)0x8000000000000000, 64) == (uint64_t)0);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 1) == (uint64_t)0x4000000000000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 2) == (uint64_t)0x2000000000000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 10) == (uint64_t)0x20000000000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 20) == (uint64_t)0x80000000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 30) == (uint64_t)0x200000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 31) == (uint64_t)0x100000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 32) == (uint64_t)0x80000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 33) == (uint64_t)0x40000000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 40) == (uint64_t)0x800000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 50) == (uint64_t)0x2000);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 60) == (uint64_t)0x8);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 61) == (uint64_t)0x4);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 62) == (uint64_t)0x2);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 63) == (uint64_t)0x1);
quiz_assert(__aeabi_llsr((uint64_t)0x8000000000000000, 64) == (uint64_t)0);
}

26
liba/test/double.c
View File

@@ -2,17 +2,17 @@
#include <assert.h>
QUIZ_CASE(double_arithmetic) {
assert((float)1.123456789101112 == 1.123456789101112f);
assert((double)1.12345f - 1.12345< 0.0000001);
assert(3.12+2.00001 - 5.12001 < 0.0000000001);
assert(1e106+1e104 - 1.01e106 < 0.0000000001);
assert(1e-106+1e-104 - 1.01e104 < 0.0000000001);
assert(3.12345678901234567890/2.0000000000000001 - 1.56172839450617276136 < 0.0000000001);
assert(1.09876e206/2.45678e207 - 0.04472358127304846180773 < 0.0000000001);
assert(3.12345678901234567890*2.0000000000000001 - 6.24691357802469167014 < 0.0000000001);
assert(1.09876e106*2.45678e107 - 2.6994115928e213 < 0.0000000001);
assert(-3.12345678901234567890+2.0000000000000001 == -1.1234567890123457);
assert(-1e36+1e34 + 9.9e35 < 0.0000000001);
assert(3.12345678901234567890-2.0000000000000001 == 1.1234567890123457);
assert(1e36-1e34 - 9.9e35 < 0.0000000001);
quiz_assert((float)1.123456789101112 == 1.123456789101112f);
quiz_assert((double)1.12345f - 1.12345< 0.0000001);
quiz_assert(3.12+2.00001 - 5.12001 < 0.0000000001);
quiz_assert(1e106+1e104 - 1.01e106 < 0.0000000001);
quiz_assert(1e-106+1e-104 - 1.01e104 < 0.0000000001);
quiz_assert(3.12345678901234567890/2.0000000000000001 - 1.56172839450617276136 < 0.0000000001);
quiz_assert(1.09876e206/2.45678e207 - 0.04472358127304846180773 < 0.0000000001);
quiz_assert(3.12345678901234567890*2.0000000000000001 - 6.24691357802469167014 < 0.0000000001);
quiz_assert(1.09876e106*2.45678e107 - 2.6994115928e213 < 0.0000000001);
quiz_assert(-3.12345678901234567890+2.0000000000000001 == -1.1234567890123457);
quiz_assert(-1e36+1e34 + 9.9e35 < 0.0000000001);
quiz_assert(3.12345678901234567890-2.0000000000000001 == 1.1234567890123457);
quiz_assert(1e36-1e34 - 9.9e35 < 0.0000000001);
}

28
liba/test/ieee754.c
View File

@@ -4,18 +4,18 @@
#include <private/ieee754.h>
QUIZ_CASE(liba_ieee754) {
assert(ieee754man32(123.456f) == 7793017);
assert(ieee754exp32(123.456f) == 133);
assert(ieee754man32(555.555f) == 713605);
assert(ieee754exp32(555.555f) == 136);
assert(ieee754man32(0.007f) == 6643778);
assert(ieee754exp32(0.007f) == 119);
assert(ieee754man64(123.456) == 0b1110110111010010111100011010100111111011111001110111);
assert(ieee754exp64(123.456) == 0b10000000101);
assert(ieee754man64(555.555) == 0b0001010111000111000010100011110101110000101000111101);
assert(ieee754exp64(555.555) == 0b10000001000);
assert(ieee754man64(0.007) == 0b1100101011000000100000110001001001101110100101111001);
assert(ieee754exp64(0.007) == 0b01111110111);
assert(isinf(INFINITY));
assert(isinf((double)INFINITY));
quiz_assert(ieee754man32(123.456f) == 7793017);
quiz_assert(ieee754exp32(123.456f) == 133);
quiz_assert(ieee754man32(555.555f) == 713605);
quiz_assert(ieee754exp32(555.555f) == 136);
quiz_assert(ieee754man32(0.007f) == 6643778);
quiz_assert(ieee754exp32(0.007f) == 119);
quiz_assert(ieee754man64(123.456) == 0b1110110111010010111100011010100111111011111001110111);
quiz_assert(ieee754exp64(123.456) == 0b10000000101);
quiz_assert(ieee754man64(555.555) == 0b0001010111000111000010100011110101110000101000111101);
quiz_assert(ieee754exp64(555.555) == 0b10000001000);
quiz_assert(ieee754man64(0.007) == 0b1100101011000000100000110001001001101110100101111001);
quiz_assert(ieee754exp64(0.007) == 0b01111110111);
quiz_assert(isinf(INFINITY));
quiz_assert(isinf((double)INFINITY));
}

8
liba/test/long.c
View File

@@ -3,14 +3,14 @@
#include <assert.h>
void assert_int64t_approximatively_equals_int64t(int64_t i, int64_t j) {
assert(i-j < 1000000);
assert(j-i < 1000000);
quiz_assert(i-j < 1000000);
quiz_assert(j-i < 1000000);
}
QUIZ_CASE(long_arithmetic) {
int64_t i = 123456789101112;
assert((float)i == 1.23456789101112e14f);
assert((double)i == 1.23456789101112e14);
quiz_assert((float)i == 1.23456789101112e14f);
quiz_assert((double)i == 1.23456789101112e14);
float f = 123456789101112.12345f;
assert_int64t_approximatively_equals_int64t((int64_t)f, 123456789101112);
double d = 123456789101112.12345f;

2
liba/test/setjmp.c
View File

@@ -10,5 +10,5 @@ QUIZ_CASE(set_jmp_long_jmp) {
}
int newres = (0 == res) ? res : res + 1;
longjmp(env, newres);
assert(false);
quiz_assert(false);
}

6
liba/test/stddef.c
View File

@@ -4,10 +4,10 @@
#include "helpers.h"
QUIZ_CASE(liba_stddef) {
assert(NULL == 0);
quiz_assert(NULL == 0);
assert_unsigned(size_t);
assert(sizeof(size_t) == __SIZEOF_SIZE_T__);
quiz_assert(sizeof(size_t) == __SIZEOF_SIZE_T__);
assert_signed(ssize_t);
assert(sizeof(ssize_t) == __SIZEOF_SIZE_T__);
quiz_assert(sizeof(ssize_t) == __SIZEOF_SIZE_T__);
}

20
liba/test/stdint.c
View File

@@ -4,18 +4,18 @@
#include "helpers.h"
QUIZ_CASE(liba_stdint_size) {
assert(sizeof(uint8_t) == 1);
assert(sizeof(uint16_t) == 2);
assert(sizeof(uint32_t) == 4);
assert(sizeof(uint64_t) == 8);
quiz_assert(sizeof(uint8_t) == 1);
quiz_assert(sizeof(uint16_t) == 2);
quiz_assert(sizeof(uint32_t) == 4);
quiz_assert(sizeof(uint64_t) == 8);
assert(sizeof(int8_t) == 1);
assert(sizeof(int16_t) == 2);
assert(sizeof(int32_t) == 4);
assert(sizeof(int64_t) == 8);
quiz_assert(sizeof(int8_t) == 1);
quiz_assert(sizeof(int16_t) == 2);
quiz_assert(sizeof(int32_t) == 4);
quiz_assert(sizeof(int64_t) == 8);
assert(sizeof(uintptr_t) == sizeof(void *));
assert(sizeof(intptr_t) == sizeof(void *));
quiz_assert(sizeof(uintptr_t) == sizeof(void *));
quiz_assert(sizeof(intptr_t) == sizeof(void *));
}
QUIZ_CASE(liba_stdint_signedness) {

6
liba/test/strlcpy.c
View File

@@ -6,7 +6,7 @@ QUIZ_CASE(liba_strlcpy) {
char * t = "Hello";
char buffer[16];
size_t result = strlcpy(buffer, t, 2);
assert(result == 1);
assert(buffer[0] == 'H');
assert(buffer[1] == NULL);
quiz_assert(result == 1);
quiz_assert(buffer[0] == 'H');
quiz_assert(buffer[1] == NULL);
}