1
0
Fork 0
mirror of https://git.rwth-aachen.de/acs/public/villas/node/ synced 2025-03-09 00:00:00 +01:00
VILLASnode/common/tests/unit/utils.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

215 lines
4.6 KiB
C++
Raw Permalink Normal View History

/* Unit tests for utilities.
*
* Author: Steffen Vogel <post@steffenvogel.de>
* SPDX-FileCopyrightText: 2014-2023 Institute for Automation of Complex Power Systems, RWTH Aachen University
* SPDX-License-Identifier: Apache-2.0
*/
#include <criterion/criterion.h>
2019-04-23 12:58:00 +02:00
#include <villas/colors.hpp>
2018-10-19 16:31:51 +02:00
#include <villas/cpuset.hpp>
#include <villas/log.hpp>
#include <villas/utils.hpp>
#include <villas/version.hpp>
2018-10-19 16:31:51 +02:00
using namespace villas::utils;
2018-08-23 13:14:39 +02:00
2020-09-11 15:16:53 +02:00
// cppcheck-suppress unknownMacro
2018-10-19 14:33:10 +02:00
TestSuite(utils, .description = "Utilities");
2018-08-23 13:14:39 +02:00
// Simple normality test for 1,2,3s intervals
Test(utils, box_muller) {
double n;
unsigned sigma[3] = {0};
unsigned iter = 1000000;
for (unsigned i = 0; i < iter; i++) {
n = boxMuller(0, 1);
if (n > 2 || n < -2)
sigma[2]++;
else if (n > 1 || n < -1)
sigma[1]++;
else
sigma[0]++;
}
#if 0
printf("%f %f %f\n",
(double) sigma[2] / iter,
(double) sigma[1] / iter,
(double) sigma[0] / iter);
#endif
// The random variable generated by the Box Muller transform is
// not an ideal normal distributed variable.
// The numbers from below are empirically measured.
cr_assert_float_eq((double)sigma[2] / iter, 0.045527, 1e-2);
cr_assert_float_eq((double)sigma[1] / iter, 0.271644, 1e-2);
cr_assert_float_eq((double)sigma[0] / iter, 0.682829, 1e-2);
}
#ifdef __linux__
Test(utils, cpuset) {
using villas::utils::CpuSet;
uintmax_t int1 = 0x1234567890ABCDEFULL;
CpuSet cset1(int1);
std::string cset1_str = cset1;
CpuSet cset2(cset1_str);
cr_assert_eq(cset1, cset2);
uintmax_t int2 = cset2;
cr_assert_eq(int1, int2);
2018-10-19 16:31:51 +02:00
CpuSet cset3("1-5");
CpuSet cset4("1,2,3,4,5");
2018-10-19 16:31:51 +02:00
cr_assert_eq(cset3, cset4);
cr_assert_eq(cset3.count(), 5);
2018-10-19 16:31:51 +02:00
cr_assert(cset3.isSet(3));
cr_assert_not(cset3.isSet(6));
2018-10-19 16:31:51 +02:00
cr_assert(cset3[3]);
cr_assert_not(cset3[6]);
2018-10-19 16:31:51 +02:00
cset4.set(6);
cr_assert(cset4[6]);
2018-10-19 16:31:51 +02:00
cset4.clear(6);
cr_assert_not(cset4[6]);
2018-10-19 16:31:51 +02:00
cr_assert_str_eq(static_cast<std::string>(cset4).c_str(), "1-5");
2018-10-19 16:31:51 +02:00
cr_assert_any_throw(CpuSet cset5("0-"));
2018-10-19 16:31:51 +02:00
CpuSet cset6;
cr_assert(cset6.empty());
cr_assert_eq(cset6.count(), 0);
2018-10-19 16:31:51 +02:00
cr_assert((~cset6).full());
cr_assert((cset1 | ~cset1).full());
cr_assert((cset1 ^ cset1).empty());
cr_assert((cset1 & cset6).empty());
2018-10-19 16:31:51 +02:00
cset1.zero();
cr_assert(cset1.empty());
}
#endif // __linux__
Test(utils, memdup) {
char orig[1024], *copy;
size_t len;
len = readRandom(orig, sizeof(orig));
cr_assert_eq(len, sizeof(orig));
copy = (char *)memdup(orig, sizeof(orig));
cr_assert_not_null(copy);
cr_assert_arr_eq(copy, orig, sizeof(orig));
free(copy);
}
Test(utils, is_aligned) {
// Positive
cr_assert(IS_ALIGNED(1, 1));
cr_assert(IS_ALIGNED(128, 64));
// Negative
cr_assert(!IS_ALIGNED(55, 16));
cr_assert(!IS_ALIGNED(55, 55));
cr_assert(!IS_ALIGNED(1128, 256));
}
Test(utils, ceil) {
cr_assert_eq(CEIL(10, 3), 4);
cr_assert_eq(CEIL(10, 5), 2);
cr_assert_eq(CEIL(4, 3), 2);
}
Test(utils, is_pow2) {
// Positive
cr_assert(IS_POW2(1));
cr_assert(IS_POW2(2));
cr_assert(IS_POW2(64));
// Negative
cr_assert(!IS_POW2(0));
cr_assert(!IS_POW2(3));
cr_assert(!IS_POW2(11111));
cr_assert(!IS_POW2(-1));
}
Test(utils, strf) {
char *buf = nullptr;
buf = strcatf(&buf, "Hallo %s", "Steffen.");
cr_assert_str_eq(buf, "Hallo Steffen.");
strcatf(&buf, " Its Monday %uth %s %u.", 13, "August", 2018);
cr_assert_str_eq(buf, "Hallo Steffen. Its Monday 13th August 2018.");
free(buf);
}
Test(utils, version) {
using villas::utils::Version;
Version v1 = Version("1.2");
Version v2 = Version("1.3");
Version v3 = Version("55");
Version v4 = Version("66");
Version v5 = Version(66);
Version v6 = Version(1, 2, 5);
Version v7 = Version("1.2.5");
cr_assert_lt(v1, v2);
cr_assert_eq(v1, v1);
cr_assert_gt(v2, v1);
cr_assert_lt(v3, v4);
cr_assert_eq(v4, v5);
cr_assert_eq(v6, v7);
}
Test(utils, sha1sum) {
int ret;
FILE *f = tmpfile();
unsigned char hash[SHA_DIGEST_LENGTH];
unsigned char expected[SHA_DIGEST_LENGTH] = {
0x69, 0xdf, 0x29, 0xdf, 0x1f, 0xf2, 0xd2, 0x5d, 0xb8, 0x68,
0x6c, 0x02, 0x8d, 0xdf, 0x40, 0xaf, 0xb3, 0xc1, 0xc9, 0x4d};
// Write the first 512 fibonaccia numbers to the file
for (int i = 0, a = 0, b = 1, c; i < 512; i++, a = b, b = c) {
c = a + b;
fwrite((void *)&c, sizeof(c), 1, f);
}
ret = sha1sum(f, hash);
cr_assert_eq(ret, 0);
cr_assert_arr_eq(hash, expected, SHA_DIGEST_LENGTH);
fclose(f);
}
Test(utils, decolor) {
char str[] =
"This " CLR_RED("is") " a " CLR_BLU("colored") " " CLR_BLD("text!");
char expect[] = "This is a colored text!";
decolor(str);
cr_assert_str_eq(str, expect);
}