systemd / systemd / 13578340107

coverage: 71.822% (+0.002%) from 71.82%

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.06
/src/test/test-parse-util.c
1 
/* SPDX-License-Identifier: LGPL-2.1-or-later */
2 









3



#include <errno.h>










4



#include <linux/netfilter/nf_tables.h>










5



#include <locale.h>










6



#include <math.h>










7



#include <sys/socket.h>










8












9



#include "alloc-util.h"










10



#include "errno-list.h"










11



#include "log.h"










12



#include "parse-util.h"










13



#include "string-util.h"










14



#include "tests.h"










15












16



TEST(parse_boolean) {




1✔





17



        ASSERT_OK_EQ(parse_boolean("1"), 1);




1✔





18



        ASSERT_OK_EQ(parse_boolean("y"), 1);




1✔





19



        ASSERT_OK_EQ(parse_boolean("Y"), 1);




1✔





20



        ASSERT_OK_EQ(parse_boolean("yes"), 1);




1✔





21



        ASSERT_OK_EQ(parse_boolean("YES"), 1);




1✔





22



        ASSERT_OK_EQ(parse_boolean("true"), 1);




1✔





23



        ASSERT_OK_EQ(parse_boolean("TRUE"), 1);




1✔





24



        ASSERT_OK_EQ(parse_boolean("on"), 1);




1✔





25



        ASSERT_OK_EQ(parse_boolean("ON"), 1);




1✔





26












27



        ASSERT_OK_ZERO(parse_boolean("0"));




1✔





28



        ASSERT_OK_ZERO(parse_boolean("n"));




1✔





29



        ASSERT_OK_ZERO(parse_boolean("N"));




1✔





30



        ASSERT_OK_ZERO(parse_boolean("no"));




1✔





31



        ASSERT_OK_ZERO(parse_boolean("NO"));




1✔





32



        ASSERT_OK_ZERO(parse_boolean("false"));




1✔





33



        ASSERT_OK_ZERO(parse_boolean("FALSE"));




1✔





34



        ASSERT_OK_ZERO(parse_boolean("off"));




1✔





35



        ASSERT_OK_ZERO(parse_boolean("OFF"));




1✔





36












37



        ASSERT_FAIL(parse_boolean("garbage"));




1✔





38



        ASSERT_FAIL(parse_boolean(""));




1✔





39



        ASSERT_FAIL(parse_boolean("full"));




1✔





40



}




1✔





41












42



TEST(parse_pid) {




1✔





43



        pid_t pid;




1✔





44












45



        ASSERT_OK_ZERO(parse_pid("100", &pid));




1✔





46



        ASSERT_EQ(pid, 100);




1✔





47












48



        ASSERT_OK_ZERO(parse_pid("0x7FFFFFFF", &pid));




1✔





49



        ASSERT_EQ(pid, 2147483647);




1✔





50












51



        pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */




1✔





52



        ASSERT_ERROR(parse_pid("0", &pid), ERANGE);




1✔





53



        ASSERT_EQ(pid, 65);




1✔





54












55



        pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */




1✔





56



        ASSERT_ERROR(parse_pid("-100", &pid), ERANGE);




1✔





57



        ASSERT_EQ(pid, 65);




1✔





58












59



        pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */




1✔





60



        ASSERT_ERROR(parse_pid("0xFFFFFFFFFFFFFFFFF", &pid), ERANGE);




1✔





61



        ASSERT_EQ(pid, 65);




1✔





62












63



        ASSERT_ERROR(parse_pid("junk", &pid), EINVAL);




1✔





64












65



        ASSERT_ERROR(parse_pid("", &pid), EINVAL);




1✔





66



}




1✔





67












68



TEST(parse_mode) {




1✔





69



        mode_t m;




1✔





70












71



        ASSERT_FAIL(parse_mode("-1", &m));




1✔





72



        ASSERT_FAIL(parse_mode("+1", &m));




1✔





73



        ASSERT_FAIL(parse_mode("", &m));




1✔





74



        ASSERT_FAIL(parse_mode("888", &m));




1✔





75



        ASSERT_FAIL(parse_mode("77777", &m));




1✔





76












77



        ASSERT_OK(parse_mode("544", &m));




1✔





78



        ASSERT_EQ(m, 0544U);




1✔





79












80



        ASSERT_OK(parse_mode("0544", &m));




1✔





81



        ASSERT_EQ(m, 0544U);




1✔





82












83



        ASSERT_OK(parse_mode("00544", &m));




1✔





84



        ASSERT_EQ(m, 0544U);




1✔





85












86



        ASSERT_OK(parse_mode("777", &m));




1✔





87



        ASSERT_EQ(m, 0777U);




1✔





88












89



        ASSERT_OK(parse_mode("0777", &m));




1✔





90



        ASSERT_EQ(m, 0777U);




1✔





91












92



        ASSERT_OK(parse_mode("00777", &m));




1✔





93



        ASSERT_EQ(m, 0777U);




1✔





94












95



        ASSERT_OK(parse_mode("7777", &m));




1✔





96



        ASSERT_EQ(m, 07777U);




1✔





97












98



        ASSERT_OK(parse_mode("07777", &m));




1✔





99



        ASSERT_EQ(m, 07777U);




1✔





100












101



        ASSERT_OK(parse_mode("007777", &m));




1✔





102



        ASSERT_EQ(m, 07777U);




1✔





103












104



        ASSERT_OK(parse_mode("0", &m));




1✔





105



        ASSERT_EQ(m, 0U);




1✔





106












107



        ASSERT_OK(parse_mode(" 1", &m));




1✔





108



        ASSERT_EQ(m, 1U);




1✔





109



}




1✔





110












111



TEST(parse_size_iec) {




1✔





112



        uint64_t bytes;




1✔





113












114



        ASSERT_ERROR(parse_size("", 1024, &bytes), EINVAL);




1✔





115












116



        ASSERT_OK_ZERO(parse_size("111", 1024, &bytes));




1✔





117



        ASSERT_EQ(bytes, 111ULL);




1✔





118












119



        ASSERT_OK_ZERO(parse_size("111.4", 1024, &bytes));




1✔





120



        ASSERT_EQ(bytes, 111ULL);




1✔





121












122



        ASSERT_OK_ZERO(parse_size(" 112 B", 1024, &bytes));




1✔





123



        ASSERT_EQ(bytes, 112ULL);




1✔





124












125



        ASSERT_OK_ZERO(parse_size(" 112.6 B", 1024, &bytes));




1✔





126



        ASSERT_EQ(bytes, 112ULL);




1✔





127












128



        ASSERT_OK_ZERO(parse_size("3.5 K", 1024, &bytes));




1✔





129



        ASSERT_EQ(bytes, 3ULL*1024 + 512);




1✔





130












131



        ASSERT_OK_ZERO(parse_size("3. K", 1024, &bytes));




1✔





132



        ASSERT_EQ(bytes, 3ULL*1024);




1✔





133












134



        ASSERT_OK_ZERO(parse_size("3.0 K", 1024, &bytes));




1✔





135



        ASSERT_EQ(bytes, 3ULL*1024);




1✔





136












137



        ASSERT_ERROR(parse_size("3. 0 K", 1024, &bytes), EINVAL);




1✔





138












139



        ASSERT_OK_ZERO(parse_size(" 4 M 11.5K", 1024, &bytes));




1✔





140



        ASSERT_EQ(bytes, 4ULL*1024*1024 + 11*1024 + 512);




1✔





141












142



        ASSERT_ERROR(parse_size("3B3.5G", 1024, &bytes), EINVAL);




1✔





143












144



        ASSERT_OK_ZERO(parse_size("3.5G3B", 1024, &bytes));




1✔





145



        ASSERT_EQ(bytes, 3ULL*1024*1024*1024 + 512*1024*1024 + 3);




1✔





146












147



        ASSERT_OK_ZERO(parse_size("3.5G 4B", 1024, &bytes));




1✔





148



        ASSERT_EQ(bytes, 3ULL*1024*1024*1024 + 512*1024*1024 + 4);




1✔





149












150



        ASSERT_ERROR(parse_size("3B3G4T", 1024, &bytes), EINVAL);




1✔





151












152



        ASSERT_OK_ZERO(parse_size("4T3G3B", 1024, &bytes));




1✔





153



        ASSERT_EQ(bytes, (4ULL*1024 + 3)*1024*1024*1024 + 3);




1✔





154












155



        ASSERT_OK_ZERO(parse_size(" 4 T 3 G 3 B", 1024, &bytes));




1✔





156



        ASSERT_EQ(bytes, (4ULL*1024 + 3)*1024*1024*1024 + 3);




1✔





157












158



        ASSERT_OK_ZERO(parse_size("12P", 1024, &bytes));




1✔





159



        ASSERT_EQ(bytes, 12ULL * 1024*1024*1024*1024*1024);




1✔





160












161



        ASSERT_ERROR(parse_size("12P12P", 1024, &bytes), EINVAL);




1✔





162












163



        ASSERT_OK_ZERO(parse_size("3E 2P", 1024, &bytes));




1✔





164



        ASSERT_EQ(bytes, (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);




1✔





165












166



        ASSERT_ERROR(parse_size("12X", 1024, &bytes), EINVAL);




1✔





167












168



        ASSERT_ERROR(parse_size("12.5X", 1024, &bytes), EINVAL);




1✔





169












170



        ASSERT_ERROR(parse_size("12.5e3", 1024, &bytes), EINVAL);




1✔





171












172



        ASSERT_ERROR(parse_size("1024E", 1024, &bytes), ERANGE);




1✔





173



        ASSERT_ERROR(parse_size("-1", 1024, &bytes), ERANGE);




1✔





174



        ASSERT_ERROR(parse_size("-1024E", 1024, &bytes), ERANGE);




1✔





175












176



        ASSERT_ERROR(parse_size("-1024P", 1024, &bytes), ERANGE);




1✔





177












178



        ASSERT_ERROR(parse_size("-10B 20K", 1024, &bytes), ERANGE);




1✔





179



}




1✔





180












181



TEST(parse_size_si) {




1✔





182



        uint64_t bytes;




1✔





183












184



        ASSERT_ERROR(parse_size("", 1000, &bytes), EINVAL);




1✔





185












186



        ASSERT_OK_ZERO(parse_size("111", 1000, &bytes));




1✔





187



        ASSERT_EQ(bytes, 111ULL);




1✔





188












189



        ASSERT_OK_ZERO(parse_size("111.4", 1000, &bytes));




1✔





190



        ASSERT_EQ(bytes, 111ULL);




1✔





191












192



        ASSERT_OK_ZERO(parse_size(" 112 B", 1000, &bytes));




1✔





193



        ASSERT_EQ(bytes, 112ULL);




1✔





194












195



        ASSERT_OK_ZERO(parse_size(" 112.6 B", 1000, &bytes));




1✔





196



        ASSERT_EQ(bytes, 112ULL);




1✔





197












198



        ASSERT_OK_ZERO(parse_size("3.5 K", 1000, &bytes));




1✔





199



        ASSERT_EQ(bytes, 3ULL*1000 + 500);




1✔





200












201



        ASSERT_OK_ZERO(parse_size("3. K", 1000, &bytes));




1✔





202



        ASSERT_EQ(bytes, 3ULL*1000);




1✔





203












204



        ASSERT_OK_ZERO(parse_size("3.0 K", 1000, &bytes));




1✔





205



        ASSERT_EQ(bytes, 3ULL*1000);




1✔





206












207



        ASSERT_ERROR(parse_size("3. 0 K", 1000, &bytes), EINVAL);




1✔





208












209



        ASSERT_OK_ZERO(parse_size(" 4 M 11.5K", 1000, &bytes));




1✔





210



        ASSERT_EQ(bytes, 4ULL*1000*1000 + 11 * 1000 + 500);




1✔





211












212



        ASSERT_ERROR(parse_size("3B3.5G", 1000, &bytes), EINVAL);




1✔





213












214



        ASSERT_OK_ZERO(parse_size("3.5G3B", 1000, &bytes));




1✔





215



        ASSERT_EQ(bytes, 3ULL*1000*1000*1000 + 500*1000*1000 + 3);




1✔





216












217



        ASSERT_OK_ZERO(parse_size("3.5G 4B", 1000, &bytes));




1✔





218



        ASSERT_EQ(bytes, 3ULL*1000*1000*1000 + 500*1000*1000 + 4);




1✔





219












220



        ASSERT_ERROR(parse_size("3B3G4T", 1000, &bytes), EINVAL);




1✔





221












222



        ASSERT_OK_ZERO(parse_size("4T3G3B", 1000, &bytes));




1✔





223



        ASSERT_EQ(bytes, (4ULL*1000 + 3)*1000*1000*1000 + 3);




1✔





224












225



        ASSERT_OK_ZERO(parse_size(" 4 T 3 G 3 B", 1000, &bytes));




1✔





226



        ASSERT_EQ(bytes, (4ULL*1000 + 3)*1000*1000*1000 + 3);




1✔





227












228



        ASSERT_OK_ZERO(parse_size("12P", 1000, &bytes));




1✔





229



        ASSERT_EQ(bytes, 12ULL * 1000*1000*1000*1000*1000);




1✔





230












231



        ASSERT_ERROR(parse_size("12P12P", 1000, &bytes), EINVAL);




1✔





232












233



        ASSERT_OK_ZERO(parse_size("3E 2P", 1000, &bytes));




1✔





234



        ASSERT_EQ(bytes, (3 * 1000 + 2ULL) * 1000*1000*1000*1000*1000);




1✔





235












236



        ASSERT_ERROR(parse_size("12X", 1000, &bytes), EINVAL);




1✔





237












238



        ASSERT_ERROR(parse_size("12.5X", 1000, &bytes), EINVAL);




1✔





239












240



        ASSERT_ERROR(parse_size("12.5e3", 1000, &bytes), EINVAL);




1✔





241












242



        ASSERT_ERROR(parse_size("1000E", 1000, &bytes), ERANGE);




1✔





243



        ASSERT_ERROR(parse_size("-1", 1000, &bytes), ERANGE);




1✔





244



        ASSERT_ERROR(parse_size("-1000E", 1000, &bytes), ERANGE);




1✔





245












246



        ASSERT_ERROR(parse_size("-1000P", 1000, &bytes), ERANGE);




1✔





247












248



        ASSERT_ERROR(parse_size("-10B 20K", 1000, &bytes), ERANGE);




1✔





249



}




1✔





250












251



TEST(parse_range) {




1✔





252



        unsigned lower, upper;




1✔





253












254



        /* Successful cases */










255



        ASSERT_OK_ZERO(parse_range("111", &lower, &upper));




1✔





256



        ASSERT_EQ(lower, 111ULL);




1✔





257



        ASSERT_EQ(upper, 111ULL);




1✔





258












259



        ASSERT_OK_ZERO(parse_range("111-123", &lower, &upper));




1✔





260



        ASSERT_EQ(lower, 111ULL);




1✔





261



        ASSERT_EQ(upper, 123ULL);




1✔





262












263



        ASSERT_OK_ZERO(parse_range("123-111", &lower, &upper));




1✔





264



        ASSERT_EQ(lower, 123ULL);




1✔





265



        ASSERT_EQ(upper, 111ULL);




1✔





266












267



        ASSERT_OK_ZERO(parse_range("123-123", &lower, &upper));




1✔





268



        ASSERT_EQ(lower, 123ULL);




1✔





269



        ASSERT_EQ(upper, 123ULL);




1✔





270












271



        ASSERT_OK_ZERO(parse_range("0", &lower, &upper));




1✔





272



        ASSERT_EQ(lower, 0ULL);




1✔





273



        ASSERT_EQ(upper, 0ULL);




1✔





274












275



        ASSERT_OK_ZERO(parse_range("0-15", &lower, &upper));




1✔





276



        ASSERT_EQ(lower, 0ULL);




1✔





277



        ASSERT_EQ(upper, 15ULL);




1✔





278












279



        ASSERT_OK_ZERO(parse_range("15-0", &lower, &upper));




1✔





280



        ASSERT_EQ(lower, 15ULL);




1✔





281



        ASSERT_EQ(upper, 0ULL);




1✔





282












283



        ASSERT_OK_ZERO(parse_range("128-65535", &lower, &upper));




1✔





284



        ASSERT_EQ(lower, 128ULL);




1✔





285



        ASSERT_EQ(upper, 65535ULL);




1✔





286












287



        ASSERT_OK_ZERO(parse_range("1024-4294967295", &lower, &upper));




1✔





288



        ASSERT_EQ(lower, 1024ULL);




1✔





289



        ASSERT_EQ(upper, 4294967295ULL);




1✔





290












291



        /* Leading whitespace is acceptable */










292



        ASSERT_OK_ZERO(parse_range(" 111", &lower, &upper));




1✔





293



        ASSERT_EQ(lower, 111ULL);




1✔





294



        ASSERT_EQ(upper, 111ULL);




1✔





295












296



        ASSERT_OK_ZERO(parse_range(" 111-123", &lower, &upper));




1✔





297



        ASSERT_EQ(lower, 111ULL);




1✔





298



        ASSERT_EQ(upper, 123ULL);




1✔





299












300



        ASSERT_OK_ZERO(parse_range("111- 123", &lower, &upper));




1✔





301



        ASSERT_EQ(lower, 111ULL);




1✔





302



        ASSERT_EQ(upper, 123ULL);




1✔





303












304



        ASSERT_OK_ZERO(parse_range("\t111-\t123", &lower, &upper));




1✔





305



        ASSERT_EQ(lower, 111ULL);




1✔





306



        ASSERT_EQ(upper, 123ULL);




1✔





307












308



        ASSERT_OK_ZERO(parse_range(" \t 111- \t 123", &lower, &upper));




1✔





309



        ASSERT_EQ(lower, 111ULL);




1✔





310



        ASSERT_EQ(upper, 123ULL);




1✔





311












312



        /* Error cases, make sure they fail as expected */










313



        lower = upper = 9999;




1✔





314



        ASSERT_ERROR(parse_range("111garbage", &lower, &upper), EINVAL);




1✔





315



        ASSERT_EQ(lower, 9999ULL);




1✔





316



        ASSERT_EQ(upper, 9999ULL);




1✔





317












318



        ASSERT_ERROR(parse_range("garbage111", &lower, &upper), EINVAL);




1✔





319



        ASSERT_EQ(lower, 9999ULL);




1✔





320



        ASSERT_EQ(upper, 9999ULL);




1✔





321












322



        ASSERT_ERROR(parse_range("garbage", &lower, &upper), EINVAL);




1✔





323



        ASSERT_EQ(lower, 9999ULL);




1✔





324



        ASSERT_EQ(upper, 9999ULL);




1✔





325












326



        ASSERT_ERROR(parse_range("111-123garbage", &lower, &upper), EINVAL);




1✔





327



        ASSERT_EQ(lower, 9999ULL);




1✔





328



        ASSERT_EQ(upper, 9999ULL);




1✔





329












330



        ASSERT_ERROR(parse_range("111garbage-123", &lower, &upper), EINVAL);




1✔





331



        ASSERT_EQ(lower, 9999ULL);




1✔





332



        ASSERT_EQ(upper, 9999ULL);




1✔





333












334



        /* Empty string */










335



        lower = upper = 9999;




1✔





336



        ASSERT_ERROR(parse_range("", &lower, &upper), EINVAL);




1✔





337



        ASSERT_EQ(lower, 9999ULL);




1✔





338



        ASSERT_EQ(upper, 9999ULL);




1✔





339












340



        /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */










341



        ASSERT_ERROR(parse_range("111--123", &lower, &upper), ERANGE);




1✔





342



        ASSERT_EQ(lower, 9999ULL);




1✔





343



        ASSERT_EQ(upper, 9999ULL);




1✔





344












345



        ASSERT_ERROR(parse_range("-123", &lower, &upper), EINVAL);




1✔





346



        ASSERT_EQ(lower, 9999ULL);




1✔





347



        ASSERT_EQ(upper, 9999ULL);




1✔





348












349



        ASSERT_ERROR(parse_range("-111-123", &lower, &upper), EINVAL);




1✔





350



        ASSERT_EQ(lower, 9999ULL);




1✔





351



        ASSERT_EQ(upper, 9999ULL);




1✔





352












353



        ASSERT_ERROR(parse_range("111-123-", &lower, &upper), EINVAL);




1✔





354



        ASSERT_EQ(lower, 9999ULL);




1✔





355



        ASSERT_EQ(upper, 9999ULL);




1✔





356












357



        ASSERT_ERROR(parse_range("111.4-123", &lower, &upper), EINVAL);




1✔





358



        ASSERT_EQ(lower, 9999ULL);




1✔





359



        ASSERT_EQ(upper, 9999ULL);




1✔





360












361



        ASSERT_ERROR(parse_range("111-123.4", &lower, &upper), EINVAL);




1✔





362



        ASSERT_EQ(lower, 9999ULL);




1✔





363



        ASSERT_EQ(upper, 9999ULL);




1✔





364












365



        ASSERT_ERROR(parse_range("111,4-123", &lower, &upper), EINVAL);




1✔





366



        ASSERT_EQ(lower, 9999ULL);




1✔





367



        ASSERT_EQ(upper, 9999ULL);




1✔





368












369



        ASSERT_ERROR(parse_range("111-123,4", &lower, &upper), EINVAL);




1✔





370



        ASSERT_EQ(lower, 9999ULL);




1✔





371



        ASSERT_EQ(upper, 9999ULL);




1✔





372












373



        /* Error on trailing dash */










374



        ASSERT_ERROR(parse_range("111-", &lower, &upper), EINVAL);




1✔





375



        ASSERT_EQ(lower, 9999ULL);




1✔





376



        ASSERT_EQ(upper, 9999ULL);




1✔





377












378



        ASSERT_ERROR(parse_range("111-123-", &lower, &upper), EINVAL);




1✔





379



        ASSERT_EQ(lower, 9999ULL);




1✔





380



        ASSERT_EQ(upper, 9999ULL);




1✔





381












382



        ASSERT_ERROR(parse_range("111--", &lower, &upper), EINVAL);




1✔





383



        ASSERT_EQ(lower, 9999ULL);




1✔





384



        ASSERT_EQ(upper, 9999ULL);




1✔





385












386



        ASSERT_ERROR(parse_range("111- ", &lower, &upper), EINVAL);




1✔





387



        ASSERT_EQ(lower, 9999ULL);




1✔





388



        ASSERT_EQ(upper, 9999ULL);




1✔





389












390



        /* Whitespace is not a separator */










391



        ASSERT_ERROR(parse_range("111 123", &lower, &upper), EINVAL);




1✔





392



        ASSERT_EQ(lower, 9999ULL);




1✔





393



        ASSERT_EQ(upper, 9999ULL);




1✔





394












395



        ASSERT_ERROR(parse_range("111\t123", &lower, &upper), EINVAL);




1✔





396



        ASSERT_EQ(lower, 9999ULL);




1✔





397



        ASSERT_EQ(upper, 9999ULL);




1✔





398












399



        ASSERT_ERROR(parse_range("111 \t 123", &lower, &upper), EINVAL);




1✔





400



        ASSERT_EQ(lower, 9999ULL);




1✔





401



        ASSERT_EQ(upper, 9999ULL);




1✔





402












403



        /* Trailing whitespace is invalid (from safe_atou) */










404



        ASSERT_ERROR(parse_range("111 ", &lower, &upper), EINVAL);




1✔





405



        ASSERT_EQ(lower, 9999ULL);




1✔





406



        ASSERT_EQ(upper, 9999ULL);




1✔





407












408



        ASSERT_ERROR(parse_range("111-123 ", &lower, &upper), EINVAL);




1✔





409



        ASSERT_EQ(lower, 9999ULL);




1✔





410



        ASSERT_EQ(upper, 9999ULL);




1✔





411












412



        ASSERT_ERROR(parse_range("111 -123", &lower, &upper), EINVAL);




1✔





413



        ASSERT_EQ(lower, 9999ULL);




1✔





414



        ASSERT_EQ(upper, 9999ULL);




1✔





415












416



        ASSERT_ERROR(parse_range("111 -123 ", &lower, &upper), EINVAL);




1✔





417



        ASSERT_EQ(lower, 9999ULL);




1✔





418



        ASSERT_EQ(upper, 9999ULL);




1✔





419












420



        ASSERT_ERROR(parse_range("111\t-123\t", &lower, &upper), EINVAL);




1✔





421



        ASSERT_EQ(lower, 9999ULL);




1✔





422



        ASSERT_EQ(upper, 9999ULL);




1✔





423












424



        ASSERT_ERROR(parse_range("111 \t -123 \t ", &lower, &upper), EINVAL);




1✔





425



        ASSERT_EQ(lower, 9999ULL);




1✔





426



        ASSERT_EQ(upper, 9999ULL);




1✔





427












428



        /* Out of the "unsigned" range, this is 1<<64 */










429



        ASSERT_ERROR(parse_range("0-18446744073709551616", &lower, &upper), ERANGE);




1✔





430



        ASSERT_EQ(lower, 9999ULL);




1✔





431



        ASSERT_EQ(upper, 9999ULL);




1✔





432



}




1✔





433












434



TEST(safe_atou_bounded) {




1✔





435



        unsigned x;




1✔





436












437



        ASSERT_OK_ZERO(safe_atou_bounded("12345", 12, 20000, &x));




1✔





438



        ASSERT_EQ(x, 12345ULL);




1✔





439












440



        ASSERT_OK_ZERO(safe_atou_bounded("12", 12, 20000, &x));




1✔





441



        ASSERT_EQ(x, 12ULL);




1✔





442












443



        ASSERT_OK_ZERO(safe_atou_bounded("20000", 12, 20000, &x));




1✔





444



        ASSERT_EQ(x, 20000ULL);




1✔





445












446



        ASSERT_ERROR(safe_atou_bounded("-1", 12, 20000, &x), ERANGE);




1✔





447



        ASSERT_ERROR(safe_atou_bounded("11", 12, 20000, &x), ERANGE);




1✔





448



        ASSERT_ERROR(safe_atou_bounded("20001", 12, 20000, &x), ERANGE);




1✔





449



}




1✔





450












451



TEST(safe_atolli) {




1✔





452



        long long l;




1✔





453












454



        ASSERT_OK_ZERO(safe_atolli("12345", &l));




1✔





455



        ASSERT_EQ(l, 12345);




1✔





456












457



        ASSERT_OK_ZERO(safe_atolli("  12345", &l));




1✔





458



        ASSERT_EQ(l, 12345);




1✔





459












460



        ASSERT_OK_ZERO(safe_atolli("-12345", &l));




1✔





461



        ASSERT_EQ(l, -12345);




1✔





462












463



        ASSERT_OK_ZERO(safe_atolli("  -12345", &l));




1✔





464



        ASSERT_EQ(l, -12345);




1✔





465












466



        ASSERT_OK_ZERO(safe_atolli("0x5", &l));




1✔





467



        ASSERT_EQ(l, 5);




1✔





468












469



        ASSERT_OK_ZERO(safe_atolli("0o6", &l));




1✔





470



        ASSERT_EQ(l, 6);




1✔





471












472



        ASSERT_OK_ZERO(safe_atolli("0B101", &l));




1✔





473



        ASSERT_EQ(l, 5);




1✔





474












475



        ASSERT_ERROR(safe_atolli("12345678901234567890", &l), ERANGE);




1✔





476



        ASSERT_ERROR(safe_atolli("-12345678901234567890", &l), ERANGE);




1✔





477



        ASSERT_ERROR(safe_atolli("junk", &l), EINVAL);




1✔





478



        ASSERT_ERROR(safe_atolli("123x", &l), EINVAL);




1✔





479



        ASSERT_ERROR(safe_atolli("12.3", &l), EINVAL);




1✔





480



        ASSERT_ERROR(safe_atolli("", &l), EINVAL);




1✔





481



}




1✔





482












483



TEST(safe_atou16) {




1✔





484



        uint16_t l;




1✔





485












486



        ASSERT_OK_ZERO(safe_atou16("12345", &l));




1✔





487



        ASSERT_EQ(l, 12345);




1✔





488












489



        ASSERT_OK_ZERO(safe_atou16("  12345", &l));




1✔





490



        ASSERT_EQ(l, 12345);




1✔





491












492



        ASSERT_OK_ZERO(safe_atou16("+12345", &l));




1✔





493



        ASSERT_EQ(l, 12345);




1✔





494












495



        ASSERT_OK_ZERO(safe_atou16("  +12345", &l));




1✔





496



        ASSERT_EQ(l, 12345);




1✔





497












498



        ASSERT_ERROR(safe_atou16("123456", &l), ERANGE);




1✔





499



        ASSERT_ERROR(safe_atou16("-1", &l), ERANGE);




1✔





500



        ASSERT_ERROR(safe_atou16("  -1", &l), ERANGE);




1✔





501



        ASSERT_ERROR(safe_atou16("junk", &l), EINVAL);




1✔





502



        ASSERT_ERROR(safe_atou16("123x", &l), EINVAL);




1✔





503



        ASSERT_ERROR(safe_atou16("12.3", &l), EINVAL);




1✔





504



        ASSERT_ERROR(safe_atou16("", &l), EINVAL);




1✔





505



}




1✔





506












507



TEST(safe_atoi16) {




1✔





508



        int16_t l;




1✔





509












510



        ASSERT_OK_ZERO(safe_atoi16("-12345", &l));




1✔





511



        ASSERT_EQ(l, -12345);




1✔





512












513



        ASSERT_OK_ZERO(safe_atoi16("  -12345", &l));




1✔





514



        ASSERT_EQ(l, -12345);




1✔





515












516



        ASSERT_OK_ZERO(safe_atoi16("+12345", &l));




1✔





517



        ASSERT_EQ(l, 12345);




1✔





518












519



        ASSERT_OK_ZERO(safe_atoi16("  +12345", &l));




1✔





520



        ASSERT_EQ(l, 12345);




1✔





521












522



        ASSERT_OK_ZERO(safe_atoi16("32767", &l));




1✔





523



        ASSERT_EQ(l, 32767);




1✔





524












525



        ASSERT_OK_ZERO(safe_atoi16("  32767", &l));




1✔





526



        ASSERT_EQ(l, 32767);




1✔





527












528



        ASSERT_OK_ZERO(safe_atoi16("0o11", &l));




1✔





529



        ASSERT_EQ(l, 9);




1✔





530












531



        ASSERT_OK_ZERO(safe_atoi16("0B110", &l));




1✔





532



        ASSERT_EQ(l, 6);




1✔





533












534



        ASSERT_ERROR(safe_atoi16("36536", &l), ERANGE);




1✔





535



        ASSERT_ERROR(safe_atoi16("-32769", &l), ERANGE);




1✔





536



        ASSERT_ERROR(safe_atoi16("junk", &l), EINVAL);




1✔





537



        ASSERT_ERROR(safe_atoi16("123x", &l), EINVAL);




1✔





538



        ASSERT_ERROR(safe_atoi16("12.3", &l), EINVAL);




1✔





539



        ASSERT_ERROR(safe_atoi16("", &l), EINVAL);




1✔





540



}




1✔





541












542



TEST(safe_atoux16) {




1✔





543



        uint16_t l;




1✔





544












545



        ASSERT_OK_ZERO(safe_atoux16("1234", &l));




1✔





546



        ASSERT_EQ(l, 0x1234);




1✔





547












548



        ASSERT_OK_ZERO(safe_atoux16("abcd", &l));




1✔





549



        ASSERT_EQ(l, 0xabcd);




1✔





550












551



        ASSERT_OK_ZERO(safe_atoux16("  1234", &l));




1✔





552



        ASSERT_EQ(l, 0x1234);




1✔





553












554



        ASSERT_ERROR(safe_atoux16("12345", &l), ERANGE);




1✔





555












556



        ASSERT_ERROR(safe_atoux16("-1", &l), ERANGE);




1✔





557












558



        ASSERT_ERROR(safe_atoux16("  -1", &l), ERANGE);




1✔





559












560



        ASSERT_OK_ZERO(safe_atoux16("0b1", &l));




1✔





561



        ASSERT_EQ(l, 177);




1✔





562












563



        ASSERT_ERROR(safe_atoux16("0o70", &l), EINVAL);




1✔





564



        ASSERT_ERROR(safe_atoux16("junk", &l), EINVAL);




1✔





565



        ASSERT_ERROR(safe_atoux16("123x", &l), EINVAL);




1✔





566



        ASSERT_ERROR(safe_atoux16("12.3", &l), EINVAL);




1✔





567



        ASSERT_ERROR(safe_atoux16("", &l), EINVAL);




1✔





568



}




1✔





569












570



TEST(safe_atou64) {




1✔





571



        uint64_t l;




1✔





572












573



        ASSERT_OK_ZERO(safe_atou64("12345", &l));




1✔





574



        ASSERT_EQ(l, 12345U);




1✔





575












576



        ASSERT_OK_ZERO(safe_atou64("  12345", &l));




1✔





577



        ASSERT_EQ(l, 12345U);




1✔





578












579



        ASSERT_OK_ZERO(safe_atou64("0o11", &l));




1✔





580



        ASSERT_EQ(l, 9U);




1✔





581












582



        ASSERT_OK_ZERO(safe_atou64("0b11", &l));




1✔





583



        ASSERT_EQ(l, 3U);




1✔





584












585



        ASSERT_ERROR(safe_atou64("18446744073709551617", &l), ERANGE);




1✔





586



        ASSERT_ERROR(safe_atou64("-1", &l), ERANGE);




1✔





587



        ASSERT_ERROR(safe_atou64("  -1", &l), ERANGE);




1✔





588



        ASSERT_ERROR(safe_atou64("junk", &l), EINVAL);




1✔





589



        ASSERT_ERROR(safe_atou64("123x", &l), EINVAL);




1✔





590



        ASSERT_ERROR(safe_atou64("12.3", &l), EINVAL);




1✔





591



        ASSERT_ERROR(safe_atou64("", &l), EINVAL);




1✔





592



}




1✔





593












594



TEST(safe_atoi64) {




1✔





595



        int64_t l;




1✔





596












597



        ASSERT_OK_ZERO(safe_atoi64("-12345", &l));




1✔





598



        ASSERT_EQ(l, -12345);




1✔





599












600



        ASSERT_OK_ZERO(safe_atoi64("  -12345", &l));




1✔





601



        ASSERT_EQ(l, -12345);




1✔





602












603



        ASSERT_OK_ZERO(safe_atoi64("32767", &l));




1✔





604



        ASSERT_EQ(l, 32767);




1✔





605












606



        ASSERT_OK_ZERO(safe_atoi64("  32767", &l));




1✔





607



        ASSERT_EQ(l, 32767);




1✔





608












609



        ASSERT_OK_ZERO(safe_atoi64("  0o20", &l));




1✔





610



        ASSERT_EQ(l, 16);




1✔





611












612



        ASSERT_OK_ZERO(safe_atoi64("  0b01010", &l));




1✔





613



        ASSERT_EQ(l, 10);




1✔





614












615



        ASSERT_ERROR(safe_atoi64("9223372036854775813", &l), ERANGE);




1✔





616



        ASSERT_ERROR(safe_atoi64("-9223372036854775813", &l), ERANGE);




1✔





617



        ASSERT_ERROR(safe_atoi64("junk", &l), EINVAL);




1✔





618



        ASSERT_ERROR(safe_atoi64("123x", &l), EINVAL);




1✔





619



        ASSERT_ERROR(safe_atoi64("12.3", &l), EINVAL);




1✔





620



        ASSERT_ERROR(safe_atoi64("", &l), EINVAL);




1✔





621



}




1✔





622












623



TEST(safe_atoux64) {




1✔





624



        uint64_t l;




1✔





625












626



        ASSERT_OK_ZERO(safe_atoux64("12345", &l));




1✔





627



        ASSERT_EQ(l, 0x12345U);




1✔





628












629



        ASSERT_OK_ZERO(safe_atoux64("  12345", &l));




1✔





630



        ASSERT_EQ(l, 0x12345U);




1✔





631












632



        ASSERT_OK_ZERO(safe_atoux64("0x12345", &l));




1✔





633



        ASSERT_EQ(l, 0x12345U);




1✔





634












635



        ASSERT_OK_ZERO(safe_atoux64("0b11011", &l));




1✔





636



        ASSERT_EQ(l, 11603985U);




1✔





637












638



        ASSERT_OK_ZERO(safe_atoux64("+12345", &l));




1✔





639



        ASSERT_EQ(l, 0x12345U);




1✔





640












641



        ASSERT_OK_ZERO(safe_atoux64("  +12345", &l));




1✔





642



        ASSERT_EQ(l, 0x12345U);




1✔





643












644



        ASSERT_OK_ZERO(safe_atoux64("+0x12345", &l));




1✔





645



        ASSERT_EQ(l, 0x12345U);




1✔





646












647



        ASSERT_OK_ZERO(safe_atoux64("+0b11011", &l));




1✔





648



        ASSERT_EQ(l, 11603985U);




1✔





649












650



        ASSERT_ERROR(safe_atoux64("0o11011", &l), EINVAL);




1✔





651



        ASSERT_ERROR(safe_atoux64("18446744073709551617", &l), ERANGE);




1✔





652



        ASSERT_ERROR(safe_atoux64("-1", &l), ERANGE);




1✔





653



        ASSERT_ERROR(safe_atoux64("  -1", &l), ERANGE);




1✔





654



        ASSERT_ERROR(safe_atoux64("junk", &l), EINVAL);




1✔





655



        ASSERT_ERROR(safe_atoux64("123x", &l), EINVAL);




1✔





656



        ASSERT_ERROR(safe_atoux64("12.3", &l), EINVAL);




1✔





657



        ASSERT_ERROR(safe_atoux64("", &l), EINVAL);




1✔





658



}




1✔





659












660



TEST(safe_atod) {




1✔





661



        double d;




1✔





662



        char *e;




1✔





663












664



        ASSERT_ERROR(safe_atod("junk", &d), EINVAL);




1✔





665












666



        ASSERT_OK_ZERO(safe_atod("0.2244", &d));




1✔





667



        assert_se(fabs(d - 0.2244) < 0.000001);




1✔





668












669



        ASSERT_ERROR(safe_atod("0,5", &d), EINVAL);




1✔





670












671



        errno = 0;




1✔





672



        strtod("0,5", &e);




1✔





673



        assert_se(*e == ',');




1✔





674












675



        ASSERT_ERROR(safe_atod("", &d), EINVAL);




1✔





676












677



        /* Check if this really is locale independent */










678



        if (setlocale(LC_NUMERIC, "de_DE.utf8")) {




1✔





679












680



                ASSERT_OK_ZERO(safe_atod("0.2244", &d));




×








UNCOV

681



                assert_se(fabs(d - 0.2244) < 0.000001);




×







682













UNCOV

683



                ASSERT_ERROR(safe_atod("0,5", &d), EINVAL);




×







684












685



                errno = 0;




×








UNCOV

686



                assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);




×







687













UNCOV

688



                ASSERT_ERROR(safe_atod("", &d), EINVAL);




×







689



        }










690












691



        /* And check again, reset */










692



        ASSERT_NOT_NULL(setlocale(LC_NUMERIC, "C"));




1✔





693












694



        ASSERT_OK_ZERO(safe_atod("0.2244", &d));




1✔





695



        assert_se(fabs(d - 0.2244) < 0.000001);




1✔





696












697



        ASSERT_ERROR(safe_atod("0,5", &d), EINVAL);




1✔





698












699



        errno = 0;




1✔





700



        strtod("0,5", &e);




1✔





701



        assert_se(*e == ',');




1✔





702












703



        ASSERT_ERROR(safe_atod("", &d), EINVAL);




1✔





704



}




1✔





705












706



TEST(parse_nice) {




1✔





707



        int n;




1✔





708












709



        ASSERT_OK(parse_nice("0", &n));




1✔





710



        ASSERT_EQ(n, 0);




1✔





711












712



        ASSERT_OK(parse_nice("+0", &n));




1✔





713



        ASSERT_EQ(n, 0);




1✔





714












715



        ASSERT_OK(parse_nice("-1", &n));




1✔





716



        ASSERT_EQ(n, -1);




1✔





717












718



        ASSERT_OK(parse_nice("-2", &n));




1✔





719



        ASSERT_EQ(n, -2);




1✔





720












721



        ASSERT_OK(parse_nice("1", &n));




1✔





722



        ASSERT_EQ(n, 1);




1✔





723












724



        ASSERT_OK(parse_nice("2", &n));




1✔





725



        ASSERT_EQ(n, 2);




1✔





726












727



        ASSERT_OK(parse_nice("+1", &n));




1✔





728



        ASSERT_EQ(n, 1);




1✔





729












730



        ASSERT_OK(parse_nice("+2", &n));




1✔





731



        ASSERT_EQ(n, 2);




1✔





732












733



        ASSERT_OK(parse_nice("-20", &n));




1✔





734



        ASSERT_EQ(n, -20);




1✔





735












736



        ASSERT_OK(parse_nice("19", &n));




1✔





737



        ASSERT_EQ(n, 19);




1✔





738












739



        ASSERT_OK(parse_nice("+19", &n));




1✔





740



        ASSERT_EQ(n, 19);




1✔





741












742



        ASSERT_ERROR(parse_nice("", &n), EINVAL);




1✔





743



        ASSERT_ERROR(parse_nice("-", &n), EINVAL);




1✔





744



        ASSERT_ERROR(parse_nice("+", &n), EINVAL);




1✔





745



        ASSERT_ERROR(parse_nice("xx", &n), EINVAL);




1✔





746



        ASSERT_ERROR(parse_nice("-50", &n), ERANGE);




1✔





747



        ASSERT_ERROR(parse_nice("50", &n), ERANGE);




1✔





748



        ASSERT_ERROR(parse_nice("+50", &n), ERANGE);




1✔





749



        ASSERT_ERROR(parse_nice("-21", &n), ERANGE);




1✔





750



        ASSERT_ERROR(parse_nice("20", &n), ERANGE);




1✔





751



        ASSERT_ERROR(parse_nice("+20", &n), ERANGE);




1✔





752



}




1✔





753












754



TEST(parse_errno) {




1✔





755



        ASSERT_OK_EQ(parse_errno("EILSEQ"), EILSEQ);




1✔





756



        ASSERT_OK_EQ(parse_errno("EINVAL"), EINVAL);




1✔





757



        ASSERT_OK_EQ(parse_errno("0"), 0);




1✔





758



        ASSERT_OK_EQ(parse_errno("1"), 1);




1✔





759



        ASSERT_OK_EQ(parse_errno("4095"), 4095);




1✔





760












761



        ASSERT_ERROR(parse_errno("-1"), ERANGE);




1✔





762



        ASSERT_ERROR(parse_errno("-3"), ERANGE);




1✔





763



        ASSERT_ERROR(parse_errno("4096"), ERANGE);




1✔





764












765



        ASSERT_ERROR(parse_errno(""), EINVAL);




1✔





766



        ASSERT_ERROR(parse_errno("12.3"), EINVAL);




1✔





767



        ASSERT_ERROR(parse_errno("123junk"), EINVAL);




1✔





768



        ASSERT_ERROR(parse_errno("junk123"), EINVAL);




1✔





769



        ASSERT_ERROR(parse_errno("255EILSEQ"), EINVAL);




1✔





770



        ASSERT_ERROR(parse_errno("EINVAL12"), EINVAL);




1✔





771



        ASSERT_ERROR(parse_errno("-EINVAL"), EINVAL);




1✔





772



        ASSERT_ERROR(parse_errno("EINVALaaa"), EINVAL);




1✔





773



}




1✔





774












775



TEST(parse_fd) {




1✔





776



        ASSERT_OK_EQ(parse_fd("0"), 0);




1✔





777



        ASSERT_OK_EQ(parse_fd("1"), 1);




1✔





778












779



        ASSERT_ERROR(parse_fd("-1"), EBADF);




1✔





780



        ASSERT_ERROR(parse_fd("-3"), EBADF);




1✔





781












782



        ASSERT_ERROR(parse_fd(""), EINVAL);




1✔





783



        ASSERT_ERROR(parse_fd("12.3"), EINVAL);




1✔





784



        ASSERT_ERROR(parse_fd("123junk"), EINVAL);




1✔





785



        ASSERT_ERROR(parse_fd("junk123"), EINVAL);




1✔





786



}




1✔





787












788



TEST(parse_mtu) {




1✔





789



        uint32_t mtu = 0;




1✔





790












791



        ASSERT_OK(parse_mtu(AF_UNSPEC, "1500", &mtu));




1✔





792



        ASSERT_EQ(mtu, 1500U);




1✔





793












794



        ASSERT_OK(parse_mtu(AF_UNSPEC, "1400", &mtu));




1✔





795



        ASSERT_EQ(mtu, 1400U);




1✔





796












797



        ASSERT_OK(parse_mtu(AF_UNSPEC, "65535", &mtu));




1✔





798



        ASSERT_EQ(mtu, 65535U);




1✔





799












800



        ASSERT_OK(parse_mtu(AF_UNSPEC, "65536", &mtu));




1✔





801



        ASSERT_EQ(mtu, 65536U);




1✔





802












803



        ASSERT_OK(parse_mtu(AF_UNSPEC, "4294967295", &mtu));




1✔





804



        ASSERT_EQ(mtu, 4294967295U);




1✔





805












806



        ASSERT_OK(parse_mtu(AF_UNSPEC, "500", &mtu));




1✔





807



        ASSERT_EQ(mtu, 500U);




1✔





808












809



        ASSERT_OK(parse_mtu(AF_UNSPEC, "1280", &mtu));




1✔





810



        ASSERT_EQ(mtu, 1280U);




1✔





811












812



        ASSERT_ERROR(parse_mtu(AF_UNSPEC, "4294967296", &mtu), ERANGE);




1✔





813












814



        ASSERT_OK(parse_mtu(AF_UNSPEC, "68", &mtu));




1✔





815



        ASSERT_EQ(mtu, 68U);




1✔





816












817



        ASSERT_OK(parse_mtu(AF_UNSPEC, "67", &mtu));




1✔





818



        ASSERT_EQ(mtu, 67U);




1✔





819












820



        ASSERT_OK(parse_mtu(AF_UNSPEC, "0", &mtu));




1✔





821



        ASSERT_EQ(mtu, 0U);




1✔





822












823



        ASSERT_ERROR(parse_mtu(AF_UNSPEC, "", &mtu), EINVAL);




1✔





824












825



        ASSERT_OK(parse_mtu(AF_INET, "1500", &mtu));




1✔





826



        ASSERT_EQ(mtu, 1500U);




1✔





827












828



        ASSERT_OK(parse_mtu(AF_INET, "1400", &mtu));




1✔





829



        ASSERT_EQ(mtu, 1400U);




1✔





830












831



        ASSERT_OK(parse_mtu(AF_INET, "65535", &mtu));




1✔





832



        ASSERT_EQ(mtu, 65535U);




1✔





833












834



        ASSERT_OK(parse_mtu(AF_INET, "65536", &mtu));




1✔





835



        ASSERT_EQ(mtu, 65536U);




1✔





836












837



        ASSERT_OK(parse_mtu(AF_INET, "4294967295", &mtu));




1✔





838



        ASSERT_EQ(mtu, 4294967295U);




1✔





839












840



        ASSERT_OK(parse_mtu(AF_INET, "500", &mtu));




1✔





841



        ASSERT_EQ(mtu, 500U);




1✔





842












843



        ASSERT_OK(parse_mtu(AF_INET, "1280", &mtu));




1✔





844



        ASSERT_EQ(mtu, 1280U);




1✔





845












846



        ASSERT_ERROR(parse_mtu(AF_INET, "4294967296", &mtu), ERANGE);




1✔





847












848



        ASSERT_OK(parse_mtu(AF_INET, "68", &mtu));




1✔





849



        ASSERT_EQ(mtu, 68U);




1✔





850












851



        ASSERT_ERROR(parse_mtu(AF_INET, "67", &mtu), ERANGE);




1✔





852



        ASSERT_ERROR(parse_mtu(AF_INET, "0", &mtu), ERANGE);




1✔





853



        ASSERT_ERROR(parse_mtu(AF_INET, "", &mtu), EINVAL);




1✔





854












855



        ASSERT_OK(parse_mtu(AF_INET6, "1280", &mtu));




1✔





856



        ASSERT_EQ(mtu, 1280U);




1✔





857












858



        ASSERT_ERROR(parse_mtu(AF_INET6, "1279", &mtu), ERANGE);




1✔





859



        ASSERT_ERROR(parse_mtu(AF_INET6, "4294967296", &mtu), ERANGE);




1✔





860



        ASSERT_ERROR(parse_mtu(AF_INET6, "68", &mtu), ERANGE);




1✔





861



        ASSERT_ERROR(parse_mtu(AF_INET6, "", &mtu), EINVAL);




1✔





862



}




1✔





863












864



TEST(parse_loadavg_fixed_point) {




1✔





865



        loadavg_t fp;




1✔





866












867



        ASSERT_OK_ZERO(parse_loadavg_fixed_point("1.23", &fp));




1✔





868



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 1U);




1✔





869



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 23U);




1✔





870












871



        ASSERT_OK_ZERO(parse_loadavg_fixed_point("1.80", &fp));




1✔





872



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 1U);




1✔





873



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 80U);




1✔





874












875



        ASSERT_OK_ZERO(parse_loadavg_fixed_point("0.07", &fp));




1✔





876



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 0U);




1✔





877



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 7U);




1✔





878












879



        ASSERT_OK_ZERO(parse_loadavg_fixed_point("0.00", &fp));




1✔





880



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 0U);




1✔





881



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 0U);




1✔





882












883



        ASSERT_OK_ZERO(parse_loadavg_fixed_point("4096.57", &fp));




1✔





884



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 4096U);




1✔





885



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 57U);




1✔





886












887



        /* Caps out at 2 digit fracs */










888



        ASSERT_ERROR(parse_loadavg_fixed_point("1.100", &fp), ERANGE);




1✔





889












890



        ASSERT_ERROR(parse_loadavg_fixed_point("4096.4096", &fp), ERANGE);




1✔





891



        ASSERT_ERROR(parse_loadavg_fixed_point("-4000.5", &fp), ERANGE);




1✔





892



        ASSERT_ERROR(parse_loadavg_fixed_point("18446744073709551615.5", &fp), ERANGE);




1✔





893



        ASSERT_ERROR(parse_loadavg_fixed_point("foobar", &fp), EINVAL);




1✔





894



        ASSERT_ERROR(parse_loadavg_fixed_point("3333", &fp), EINVAL);




1✔





895



        ASSERT_ERROR(parse_loadavg_fixed_point("1.2.3", &fp), EINVAL);




1✔





896



        ASSERT_ERROR(parse_loadavg_fixed_point(".", &fp), EINVAL);




1✔





897



        ASSERT_ERROR(parse_loadavg_fixed_point("", &fp), EINVAL);




1✔





898



}




1✔





899












900



TEST(nft_identifier_valid) {




1✔





901



        ASSERT_TRUE(nft_identifier_valid("a"));




1✔





902



        ASSERT_TRUE(nft_identifier_valid("abc"));




1✔





903



        ASSERT_TRUE(nft_identifier_valid("abc"));




1✔





904



        ASSERT_TRUE(nft_identifier_valid("a012/_\\."));




1✔





905












906



        ASSERT_FALSE(nft_identifier_valid(NULL));




1✔





907



        ASSERT_FALSE(nft_identifier_valid(""));




1✔





908



        ASSERT_FALSE(nft_identifier_valid("1234"));




1✔





909



        ASSERT_FALSE(nft_identifier_valid("1xyz"));




1✔





910



        ASSERT_FALSE(nft_identifier_valid("abc?&*"));




1✔





911












912



        char s[NFT_NAME_MAXLEN+1];




1✔





913



        *(char*) mempset(s, 'a', NFT_NAME_MAXLEN) = '\0';




1✔





914



        ASSERT_FALSE(nft_identifier_valid(s));




1✔





915



}




1✔





916












917



DEFINE_TEST_MAIN(LOG_INFO);




1✔



















    

  • 

    •