Training courses

Kernel and Embedded Linux

Bootlin training courses

Embedded Linux, kernel,
Yocto Project, Buildroot, real-time,
graphics, boot time, debugging...

Bootlin logo

Elixir Cross Referencer

Open Menu /external/bsd/ntp/dist/tests/libntp/lfptostr.c 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/* 
 * This file contains test for both mfptoa and mfptoms (which uses dolfptoa),
 * since all these functions are very similar. It also tests ulfptoa, which is
 * a macro.
 */

#include "config.h"
#include "ntp_stdlib.h"
#include "ntp_fp.h"

#include "unity.h"

static const int LFP_MAX_PRECISION = 10;
static const int LFP_MAX_PRECISION_MS = 7;

static const int ONE_FOURTH = 1073741824; /* (1 << 30) */
static const int HALF = (1 << 31);
static const int THREE_FOURTH = -1073741824;
static const int HALF_PROMILLE_UP = 2147484; /* slightly more than 0.0005 */
static const int HALF_PROMILLE_DOWN = 2147483; /* slightly less than 0.0005 */


void setUp(void);
void test_PositiveInteger(void);
void test_NegativeInteger(void);
void test_PositiveIntegerWithFraction(void);
void test_NegativeIntegerWithFraction(void);
void test_RoundingDownToInteger(void);
void test_RoundingMiddleToInteger(void);
void test_RoundingUpToInteger(void);
void test_SingleDecimal(void);
void test_MillisecondsRoundingUp(void);
void test_MillisecondsRoundingDown(void);
void test_UnsignedInteger(void);


void
setUp(void)
{
	init_lib();

	return;
}


void
test_PositiveInteger(void) {
	l_fp test = {{200}, 0}; /* exact 200.0000000000 */

	TEST_ASSERT_EQUAL_STRING("200.0000000000", mfptoa(test.l_ui, test.l_uf, LFP_MAX_PRECISION));
	TEST_ASSERT_EQUAL_STRING("200000.0000000", mfptoms(test.l_ui, test.l_uf, LFP_MAX_PRECISION_MS));
}

void
test_NegativeInteger(void) {
	l_fp test = {{-100}, 0}; /* -100 */

	TEST_ASSERT_EQUAL_STRING("-100.0000000000", lfptoa(&test, LFP_MAX_PRECISION));
	TEST_ASSERT_EQUAL_STRING("-100000.0000000", lfptoms(&test, LFP_MAX_PRECISION_MS));
}

void
test_PositiveIntegerWithFraction(void) {
	l_fp test = {{200}, ONE_FOURTH}; /* 200.25 */

	TEST_ASSERT_EQUAL_STRING("200.2500000000", lfptoa(&test, LFP_MAX_PRECISION));
	TEST_ASSERT_EQUAL_STRING("200250.0000000", lfptoms(&test, LFP_MAX_PRECISION_MS));
}

void
test_NegativeIntegerWithFraction(void) {
	l_fp test = {{-100}, ONE_FOURTH}; /* -99.75 */

	TEST_ASSERT_EQUAL_STRING("-99.7500000000", lfptoa(&test, LFP_MAX_PRECISION));
	TEST_ASSERT_EQUAL_STRING("-99750.0000000", lfptoms(&test, LFP_MAX_PRECISION_MS));
}

void
test_RoundingDownToInteger(void) {
	l_fp test = {{10}, ONE_FOURTH}; /* 10.25 */

	TEST_ASSERT_EQUAL_STRING("10", lfptoa(&test, 0));
	TEST_ASSERT_EQUAL_STRING("10250", lfptoms(&test, 0));
}

void
test_RoundingMiddleToInteger(void) {
	l_fp test = {{10}, HALF}; /* 10.5 */

	TEST_ASSERT_EQUAL_STRING("11", lfptoa(&test, 0));
	TEST_ASSERT_EQUAL_STRING("10500", lfptoms(&test, 0));
}

void
test_RoundingUpToInteger(void) {
	l_fp test = {{5}, THREE_FOURTH}; /* 5.75 */

	TEST_ASSERT_EQUAL_STRING("6", lfptoa(&test, 0));
	TEST_ASSERT_EQUAL_STRING("5750", lfptoms(&test, 0));
}

void
test_SingleDecimal(void) {
	l_fp test = {{8}, ONE_FOURTH}; /* 8.25 */

	TEST_ASSERT_EQUAL_STRING("8.3", lfptoa(&test, 1));
	TEST_ASSERT_EQUAL_STRING("8250.0", lfptoms(&test, 1));
}

void
test_MillisecondsRoundingUp(void) {
	l_fp test = {{1}, HALF_PROMILLE_UP}; /* slightly more than 1.0005 */

	TEST_ASSERT_EQUAL_STRING("1.0", lfptoa(&test, 1));

	TEST_ASSERT_EQUAL_STRING("1000.5", lfptoms(&test, 1));
	TEST_ASSERT_EQUAL_STRING("1001", lfptoms(&test, 0));
}

void
test_MillisecondsRoundingDown(void) {
	l_fp test = {{1}, HALF_PROMILLE_DOWN}; /* slightly less than 1.0005 */

	TEST_ASSERT_EQUAL_STRING("1.0", lfptoa(&test, 1));

	TEST_ASSERT_EQUAL_STRING("1000.5", lfptoms(&test, 1));
	TEST_ASSERT_EQUAL_STRING("1000", lfptoms(&test, 0));
}

void test_UnsignedInteger(void) {
	l_fp test = {{3000000000UL}, 0};

	TEST_ASSERT_EQUAL_STRING("3000000000.0", ulfptoa(&test, 1));
}