You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
399 lines
17 KiB
399 lines
17 KiB
#ifdef TEST
|
|
|
|
#include "unity.h"
|
|
|
|
#include "addition.h"
|
|
|
|
num carry[1];
|
|
|
|
unsigned int e = 0x00800000;
|
|
|
|
unsigned long long ed = 0x0010000000000000;
|
|
|
|
union {
|
|
float floating;
|
|
unsigned int integer;
|
|
} number[6];
|
|
|
|
union {
|
|
double dnum;
|
|
unsigned long long lnum;
|
|
} numberd[6];
|
|
|
|
void setUp(void)
|
|
{
|
|
}
|
|
|
|
void tearDown(void)
|
|
{
|
|
}
|
|
|
|
void test_addition_full_adder_nullplusnullgleichnull(void)
|
|
{
|
|
num result[1];
|
|
num expected = 0;
|
|
|
|
full_adder(result, carry, 0, 0, 0);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected, result[0]);
|
|
}
|
|
|
|
void test_addition_full_adder_nullplusnullgleichnullmituebertrag(void)
|
|
{
|
|
num result[1];
|
|
num expected = 1;
|
|
|
|
full_adder(result, carry, 0, 0, 1);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected, result[0]);
|
|
}
|
|
|
|
void test_addition_full_adder_zahlpluszahlgleichsummeohneuebertrag(void)
|
|
{
|
|
num result[5];
|
|
num expected[5] = { 0, 1, 1, 1, 1};
|
|
|
|
full_adder((result+0), carry, 1, 0, 1);
|
|
full_adder((result+1), carry, 0, 1, 0);
|
|
full_adder((result+2), carry, 1, 0, 0);
|
|
full_adder((result+3), carry, 0, 0, 1);
|
|
full_adder((result+4), carry, 1, 1, 1);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_full_adder_completesumwithcarry(void)
|
|
{
|
|
num result[5], carryresult[5];
|
|
num expected[5] = { 0, 0, 1, 1, 0}, expectedcarry[5] = { 1, 1, 1, 0, 0};
|
|
|
|
full_adder(result+0, carryresult+0, 0, 1, 1);
|
|
full_adder(result+1, carryresult+1, 1, 1, 0);
|
|
full_adder(result+2, carryresult+2, 1, 1, 1);
|
|
full_adder(result+3, carryresult+3, 0, 1, 0);
|
|
full_adder(result+4, carryresult+4, 0, 0, 0);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[4], result[4]);
|
|
TEST_ASSERT_EQUAL_UINT(expectedcarry[0], carryresult[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expectedcarry[1], carryresult[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expectedcarry[2], carryresult[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expectedcarry[3], carryresult[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expectedcarry[4], carryresult[4]);
|
|
}
|
|
|
|
void test_addition_addition_uint_basecasezeropluszeroequalzero(void)
|
|
{
|
|
unsigned int result;
|
|
unsigned int expected = 0;
|
|
|
|
result = addition_uint(0, 0);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected, result);
|
|
}
|
|
|
|
void test_addition_addition_uint_basecaseonescolumns(void)
|
|
{
|
|
unsigned int result[2];
|
|
unsigned int expected[2] = { 1, 1 };
|
|
|
|
result[0] = addition_uint(1, 0);
|
|
result[1] = addition_uint(0, 1);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
}
|
|
|
|
void test_addition_addition_uint_basecasetotenscolumns(void)
|
|
{
|
|
unsigned int result[5];
|
|
unsigned int expected[5] = { 3, 3, 2, 3, 3 };
|
|
|
|
result[0] = addition_uint(0, 3);
|
|
result[1] = addition_uint(1, 2);
|
|
result[2] = addition_uint(1, 1);
|
|
result[3] = addition_uint(2, 1);
|
|
result[4] = addition_uint(3, 0);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_addition_uint_allunsignedinteger(void)
|
|
{
|
|
unsigned int result[5];
|
|
unsigned int expected[5] = { 88879736, __UINT32_MAX__, 66558, __UINT32_MAX__, 477905879 };
|
|
|
|
result[0] = addition_uint(13456275, 75423461);
|
|
result[1] = addition_uint(4294967294, 1);
|
|
result[2] = addition_uint(1023, 65535);
|
|
result[3] = addition_uint(0, 4294967295);
|
|
result[4] = addition_uint(54321567,423584312);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_sign_floatingnumber(void)
|
|
{
|
|
unsigned int result[2];
|
|
unsigned int expected[2] = { 0, 1 };
|
|
number[0].floating = 1, number[1].floating = -1;
|
|
|
|
result[0] = sign_float(number[0].integer);
|
|
result[1] = sign_float(number[1].integer);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
}
|
|
|
|
void test_addition_precision_floatingnumber(void)
|
|
{
|
|
unsigned int result[5];
|
|
number[0].floating = 0, number[1].floating = -34753168, number[2].floating = 75613594, number[3].floating = -0.00000044568721, number[4].floating = 0.0000004796123;
|
|
unsigned int expected[5] = { ( number[0].integer << 9) >> 9 , ( number[1].integer << 9) >> 9, ( number[2].integer << 9) >> 9, ( number[3].integer << 9) >> 9, ( number[4].integer << 9) >> 9};
|
|
|
|
result[0] = precision_float( number[0].integer );
|
|
result[1] = precision_float( number[1].integer );
|
|
result[2] = precision_float( number[2].integer );
|
|
result[3] = precision_float( number[3].integer );
|
|
result[4] = precision_float( number[4].integer );
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_exponent_floatingnumber(void)
|
|
{
|
|
unsigned int result[5];
|
|
number[0].floating = 0, number[1].floating = -762134982, number[2].floating = 47621349, number[3].floating = -0.0000078961354, number[4].floating = 0.00001568943;
|
|
unsigned int expected[5] = { ( number[0].integer << 1) >> 24 , ( number[1].integer << 1) >> 24, ( number[2].integer << 1) >> 24, ( number[3].integer << 1) >> 24, ( number[4].integer << 1) >> 24};
|
|
|
|
result[0] = exponent_float( number[0].integer );
|
|
result[1] = exponent_float( number[1].integer );
|
|
result[2] = exponent_float( number[2].integer );
|
|
result[3] = exponent_float( number[3].integer );
|
|
result[4] = exponent_float( number[4].integer );
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_addition_precision_float_positivnumberlowerthan2tothepowerof24(void)
|
|
{
|
|
unsigned int result[2];
|
|
number[0].floating = 652468761.2348, number[1].floating = 2.675312546943, number[2].floating = 321647956212.2146, number[3].floating = 0.00000324567861, number[4].floating = number[0].floating + number[1].floating; number[5].floating = number[2].floating + number[3].floating;
|
|
unsigned int expected[2] = { precision_float(number[4].integer), precision_float(number[5].integer) };
|
|
|
|
unsigned int e0, e1, e2, e3, p0, p1, p2, p3;
|
|
|
|
e0 = exponent_float(number[0].integer), e1 = exponent_float(number[1].integer), e2 = exponent_float(number[2].integer), e3 = exponent_float(number[3].integer);
|
|
p0 = precision_float(number[0].integer) | e, p1 = precision_float(number[1].integer) | e, p2 = precision_float(number[2].integer) | e, p3 = precision_float(number[3].integer) | e;
|
|
|
|
p1 >>= e0 - e1, p3 >>= e2 - e3;
|
|
|
|
result[0] = addition_precision_float( p0, p1 ) ^ e;
|
|
result[1] = addition_precision_float( p2, p3 ) ^ e;
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
}
|
|
|
|
void test_addition_output_float_numberwithsignexponentprecision(void)
|
|
{
|
|
unsigned int result[5];
|
|
number[0].floating = 1468921, number[1].floating = -32468127698, number[2].floating = 0.000000795311468, number[3].floating = -0.00000843214521, number[4].floating = 14;
|
|
unsigned int expected[5] = { number[0].integer, number[1].integer, number[2].integer, number[3].integer, number[4].integer };
|
|
|
|
unsigned int s0, s1, s2, s3, s4, e0, e1, e2, e3, e4, p0, p1, p2, p3, p4;
|
|
|
|
s0 = sign_float(number[0].integer), s1 = sign_float(number[1].integer), s2 = sign_float(number[2].integer), s3 = sign_float(number[3].integer), s4 = sign_float(number[4].integer);
|
|
e0 = exponent_float(number[0].integer), e1 = exponent_float(number[1].integer), e2 = exponent_float(number[2].integer), e3 = exponent_float(number[3].integer), e4 = exponent_float(number[4].integer);
|
|
p0 = precision_float(number[0].integer), p1 = precision_float(number[1].integer), p2 = precision_float(number[2].integer), p3 = precision_float(number[3].integer), p4 = precision_float(number[4].integer);
|
|
result[0] = output_float(s0, e0, p0);
|
|
result[1] = output_float(s1, e1, p1);
|
|
result[2] = output_float(s2, e2, p2);
|
|
result[3] = output_float(s3, e3, p3);
|
|
result[4] = output_float(s4, e4, p4);
|
|
|
|
TEST_ASSERT_EQUAL_UINT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_addition_float_0plus0gleich0(void)
|
|
{
|
|
float result;
|
|
float expected = (float) 0.0;
|
|
|
|
result = addition_float( (float) 0.0, (float) 0.0);
|
|
|
|
TEST_ASSERT_EQUAL_FLOAT(expected, result);
|
|
}
|
|
|
|
void test_addition_addition_float_0plusnumbergleichnumber(void)
|
|
{
|
|
float result[5];
|
|
number[0].floating = 45672.56487, number[1].floating = -9531145672.467, number[2].floating = 91357634, number[3].floating = -0.0000000079533144, number[4].floating = 0.0756215698;
|
|
float expected[5] = { number[0].floating, number[1].floating, number[2].floating, number[3].floating, number[4].floating };
|
|
|
|
result[0] = addition_float(number[0].floating, (float) 0.0);
|
|
result[1] = addition_float((float) 0.0, number[1].floating);
|
|
result[2] = addition_float(number[2].floating, (float) 0.0);
|
|
result[3] = addition_float((float) 0.0, number[3].floating);
|
|
result[4] = addition_float((float) 0.0, number[4].floating);
|
|
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_addition_float_sumofpositivnumbers(void)
|
|
{
|
|
float result[3];
|
|
number[0].floating = 31972543.42176, number[1].floating = 423576.006432054, number[2].floating = 1346.4546124016, number[3].floating = 75620056402.5431, number[4].floating = 0.5351401453104, number[5].floating = 0.469178612;
|
|
float expected[3] = { number[0].floating + number[1].floating, number[2].floating + number[3].floating, number[4].floating + number[5].floating };
|
|
|
|
result[0] = addition_float(number[0].floating, number[1].floating);
|
|
result[1] = addition_float(number[2].floating, number[3].floating);
|
|
result[2] = addition_float(number[4].floating, number[5].floating);
|
|
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_FLOAT(expected[2], result[2]);
|
|
}
|
|
|
|
void test_addition_sign_double_numbers(void)
|
|
{
|
|
unsigned long long result[2];
|
|
unsigned long long expected[2] = { 1, 0 };
|
|
numberd[0].dnum = -3004683105640520235, numberd[1].dnum = 0.05313546453135;
|
|
|
|
result[0] = sign_double(numberd[0].lnum);
|
|
result[1] = sign_double(numberd[1].lnum);
|
|
|
|
TEST_ASSERT_EQUAL_UINT64(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[1], result[1]);
|
|
}
|
|
|
|
void test_addition_precision_double_numbers(void)
|
|
{
|
|
unsigned long long result[5];
|
|
numberd[0].dnum = 3216752.2348648931012, numberd[1].dnum = -79865431546, numberd[2].dnum = 203, numberd[3].dnum = -0.00460023540056432002, numberd[4].dnum = 0.000000000791340265431213;
|
|
unsigned long long expected[5] = { (numberd[0].lnum << 12) >> 12 , (numberd[1].lnum << 12) >> 12, (numberd[2].lnum << 12) >> 12, (numberd[3].lnum << 12) >> 12, (numberd[4].lnum << 12) >> 12};
|
|
|
|
result[0] = precision_double( numberd[0].lnum );
|
|
result[1] = precision_double( numberd[1].lnum );
|
|
result[2] = precision_double( numberd[2].lnum );
|
|
result[3] = precision_double( numberd[3].lnum );
|
|
result[4] = precision_double( numberd[4].lnum );
|
|
|
|
TEST_ASSERT_EQUAL_UINT64(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_exponent_double_numbers(void)
|
|
{
|
|
unsigned long long result[5];
|
|
numberd[0].dnum = 830046503435461000, numberd[1].dnum = -906056810308432, numberd[2].dnum = 0.5315020335035034357, numberd[3].dnum = -34, numberd[4].dnum = 94315454312021310;
|
|
unsigned long long expected[5] = { (numberd[0].lnum << 1) >> 53 , (numberd[1].lnum << 1) >> 53, (numberd[2].lnum << 1) >> 53, (numberd[3].lnum << 1) >> 53, (numberd[4].lnum << 1) >> 53};
|
|
|
|
result[0] = exponent_double( numberd[0].lnum );
|
|
result[1] = exponent_double( numberd[1].lnum );
|
|
result[2] = exponent_double( numberd[2].lnum );
|
|
result[3] = exponent_double( numberd[3].lnum );
|
|
result[4] = exponent_double( numberd[4].lnum );
|
|
|
|
TEST_ASSERT_EQUAL_UINT64(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_output_double_numberwithsignexponentprecision(void)
|
|
{
|
|
unsigned long long result[5];
|
|
numberd[0].dnum = 7, numberd[1].dnum = -0.0000000006432154846123454, numberd[2].dnum = 731202035312050934, numberd[3].dnum = 0.0000009341213541974341, numberd[4].dnum = -9443345434194197313103.1136;
|
|
unsigned long long expected[5] = { numberd[0].lnum, numberd[1].lnum, numberd[2].lnum, numberd[3].lnum, numberd[4].lnum };
|
|
|
|
unsigned long long s0, s1, s2, s3, s4, e0, e1, e2, e3, e4, p0, p1, p2, p3, p4;
|
|
|
|
s0 = sign_double(numberd[0].lnum), s1 = sign_double(numberd[1].lnum), s2 = sign_double(numberd[2].lnum), s3 = sign_double(numberd[3].lnum), s4 = sign_double(numberd[4].lnum);
|
|
e0 = exponent_double(numberd[0].lnum), e1 = exponent_double(numberd[1].lnum), e2 = exponent_double(numberd[2].lnum), e3 = exponent_double(numberd[3].lnum), e4 = exponent_double(numberd[4].lnum);
|
|
p0 = precision_double(numberd[0].lnum), p1 = precision_double(numberd[1].lnum), p2 = precision_double(numberd[2].lnum), p3 = precision_double(numberd[3].lnum), p4 = precision_double(numberd[4].lnum);
|
|
result[0] = output_double(s0, e0, p0);
|
|
result[1] = output_double(s1, e1, p1);
|
|
result[2] = output_double(s2, e2, p2);
|
|
result[3] = output_double(s3, e3, p3);
|
|
result[4] = output_double(s4, e4, p4);
|
|
|
|
TEST_ASSERT_EQUAL_UINT64(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[2], result[2]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[3], result[3]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[4], result[4]);
|
|
}
|
|
|
|
void test_addition_addition_precision_double_positivnumberlowerthan2tothepowerof53(void)
|
|
{
|
|
unsigned long long result[2];
|
|
numberd[0].dnum = 0.0000434534473513646, numberd[1].dnum = 0.0000000036543515354, numberd[2].dnum = 9735105130351.113543, numberd[3].dnum = 78531.13543441354, numberd[4].dnum = numberd[0].dnum + numberd[1].dnum; numberd[5].dnum = numberd[2].dnum + numberd[3].dnum;
|
|
unsigned long long expected[2] = { precision_double(numberd[4].lnum), precision_double(numberd[5].lnum) };
|
|
|
|
unsigned long long e0, e1, e2, e3, p0, p1, p2, p3;
|
|
|
|
e0 = exponent_double(numberd[0].lnum), e1 = exponent_double(numberd[1].lnum), e2 = exponent_double(numberd[2].lnum), e3 = exponent_double(numberd[3].lnum);
|
|
p0 = precision_double(numberd[0].lnum) | ed, p1 = precision_double(numberd[1].lnum) | ed, p2 = precision_double(numberd[2].lnum) | ed, p3 = precision_double(numberd[3].lnum) | ed;
|
|
|
|
p1 >>= e0 - e1, p3 >>= e2 - e3;
|
|
|
|
result[0] = addition_precision_double( p0, p1 ) ^ ed;
|
|
result[1] = addition_precision_double( p2, p3 ) ^ ed;
|
|
|
|
TEST_ASSERT_EQUAL_UINT64(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_UINT64(expected[1], result[1]);
|
|
}
|
|
|
|
void test_addition_addition_double_sumofpositivnumbers(void)
|
|
{
|
|
double result[3];
|
|
numberd[0].dnum = 93415405440107.45515, numberd[1].dnum = 78634100530331.45341, numberd[2].dnum = 0.00043419445734139434, numberd[3].dnum = 940313051379341035.3739, numberd[4].dnum = 0.000007936136439442513434, numberd[5].dnum = 0.0000000093953351384343102;
|
|
double expected[3] = { numberd[0].dnum + numberd[1].dnum, numberd[2].dnum + numberd[3].dnum, numberd[4].dnum + numberd[5].dnum };
|
|
|
|
result[0] = addition_double(numberd[0].dnum, numberd[1].dnum);
|
|
result[1] = addition_double(numberd[2].dnum, numberd[3].dnum);
|
|
result[2] = addition_double(numberd[4].dnum, numberd[5].dnum);
|
|
|
|
TEST_ASSERT_EQUAL_DOUBLE(expected[0], result[0]);
|
|
TEST_ASSERT_EQUAL_DOUBLE(expected[1], result[1]);
|
|
TEST_ASSERT_EQUAL_DOUBLE(expected[2], result[2]);
|
|
}
|
|
|
|
#endif // TEST
|