systemd / systemd / 19020191358

coverage: 72.222% (-0.02%) from 72.241%
19020191358

push

github

web-flow 
Enhance docs for ukify and direct kernel boots (#39516)

305246 of 422650 relevant lines covered (72.22%)

1085243.28 hits per line

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

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









3



#include <linux/netfilter/nf_tables.h>










4



#include <locale.h>










5



#include <math.h>










6



#include <sys/socket.h>










7












8



#include "capability-util.h"










9



#include "locale-util.h"










10



#include "parse-util.h"










11



#include "tests.h"










12












13



TEST(parse_boolean) {




1✔





14



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




1✔





15



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




1✔





16



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




1✔





17



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




1✔





18



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




1✔





19



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




1✔





20



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




1✔





21



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




1✔





22



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




1✔





23












24



        ASSERT_OK_ZERO(parse_boolean("0"));




1✔





25



        ASSERT_OK_ZERO(parse_boolean("n"));




1✔





26



        ASSERT_OK_ZERO(parse_boolean("N"));




1✔





27



        ASSERT_OK_ZERO(parse_boolean("no"));




1✔





28



        ASSERT_OK_ZERO(parse_boolean("NO"));




1✔





29



        ASSERT_OK_ZERO(parse_boolean("false"));




1✔





30



        ASSERT_OK_ZERO(parse_boolean("FALSE"));




1✔





31



        ASSERT_OK_ZERO(parse_boolean("off"));




1✔





32



        ASSERT_OK_ZERO(parse_boolean("OFF"));




1✔





33












34



        ASSERT_FAIL(parse_boolean("garbage"));




1✔





35



        ASSERT_FAIL(parse_boolean(""));




1✔





36



        ASSERT_FAIL(parse_boolean("full"));




1✔





37



}




1✔





38












39



TEST(parse_pid) {




1✔





40



        pid_t pid;




1✔





41












42



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




1✔





43



        ASSERT_EQ(pid, 100);




1✔





44












45



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




1✔





46



        ASSERT_EQ(pid, 2147483647);




1✔





47












48



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




1✔





49



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




1✔





50



        ASSERT_EQ(pid, 65);




1✔





51












52



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




1✔





53



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




1✔





54



        ASSERT_EQ(pid, 65);




1✔





55












56



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




1✔





57



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




1✔





58



        ASSERT_EQ(pid, 65);




1✔





59












60



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




1✔





61












62



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




1✔





63



}




1✔





64












65



TEST(parse_mode) {




1✔





66



        mode_t m;




1✔





67












68



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




1✔





69



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




1✔





70



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




1✔





71



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




1✔





72



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




1✔





73












74



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




1✔





75



        ASSERT_EQ(m, 0544U);




1✔





76












77



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




1✔





78



        ASSERT_EQ(m, 0544U);




1✔





79












80



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




1✔





81



        ASSERT_EQ(m, 0544U);




1✔





82












83



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




1✔





84



        ASSERT_EQ(m, 0777U);




1✔





85












86



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




1✔





87



        ASSERT_EQ(m, 0777U);




1✔





88












89



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




1✔





90



        ASSERT_EQ(m, 0777U);




1✔





91












92



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




1✔





93



        ASSERT_EQ(m, 07777U);




1✔





94












95



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




1✔





96



        ASSERT_EQ(m, 07777U);




1✔





97












98



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




1✔





99



        ASSERT_EQ(m, 07777U);




1✔





100












101



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




1✔





102



        ASSERT_EQ(m, 0U);




1✔





103












104



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




1✔





105



        ASSERT_EQ(m, 1U);




1✔





106



}




1✔





107












108



TEST(parse_size_iec) {




1✔





109



        uint64_t bytes;




1✔





110












111



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




1✔





112












113



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




1✔





114



        ASSERT_EQ(bytes, 111ULL);




1✔





115












116



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




1✔





117



        ASSERT_EQ(bytes, 111ULL);




1✔





118












119



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




1✔





120



        ASSERT_EQ(bytes, 112ULL);




1✔





121












122



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




1✔





123



        ASSERT_EQ(bytes, 112ULL);




1✔





124












125



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




1✔





126



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




1✔





127












128



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




1✔





129



        ASSERT_EQ(bytes, 3ULL*1024);




1✔





130












131



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




1✔





132



        ASSERT_EQ(bytes, 3ULL*1024);




1✔





133












134



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




1✔





135












136



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




1✔





137



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




1✔





138












139



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




1✔





140












141



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




1✔





142



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




1✔





143












144



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




1✔





145



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




1✔





146












147



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




1✔





148












149



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




1✔





150



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




1✔





151












152



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




1✔





153



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




1✔





154












155



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




1✔





156



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




1✔





157












158



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




1✔





159












160



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




1✔





161



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




1✔





162












163



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




1✔





164












165



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




1✔





166












167



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




1✔





168












169



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




1✔





170



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




1✔





171



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




1✔





172












173



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




1✔





174












175



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




1✔





176



}




1✔





177












178



TEST(parse_size_si) {




1✔





179



        uint64_t bytes;




1✔





180












181



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




1✔





182












183



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




1✔





184



        ASSERT_EQ(bytes, 111ULL);




1✔





185












186



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




1✔





187



        ASSERT_EQ(bytes, 111ULL);




1✔





188












189



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




1✔





190



        ASSERT_EQ(bytes, 112ULL);




1✔





191












192



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




1✔





193



        ASSERT_EQ(bytes, 112ULL);




1✔





194












195



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




1✔





196



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




1✔





197












198



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




1✔





199



        ASSERT_EQ(bytes, 3ULL*1000);




1✔





200












201



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




1✔





202



        ASSERT_EQ(bytes, 3ULL*1000);




1✔





203












204



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




1✔





205












206



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




1✔





207



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




1✔





208












209



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




1✔





210












211



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




1✔





212



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




1✔





213












214



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




1✔





215



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




1✔





216












217



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




1✔





218












219



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




1✔





220



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




1✔





221












222



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




1✔





223



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




1✔





224












225



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




1✔





226



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




1✔





227












228



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




1✔





229












230



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




1✔





231



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




1✔





232












233



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




1✔





234












235



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




1✔





236












237



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




1✔





238












239



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




1✔





240



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




1✔





241



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




1✔





242












243



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




1✔





244












245



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




1✔





246



}




1✔





247












248



TEST(parse_range) {




1✔





249



        unsigned lower, upper;




1✔





250












251



        /* Successful cases */










252



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




1✔





253



        ASSERT_EQ(lower, 111ULL);




1✔





254



        ASSERT_EQ(upper, 111ULL);




1✔





255












256



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




1✔





257



        ASSERT_EQ(lower, 111ULL);




1✔





258



        ASSERT_EQ(upper, 123ULL);




1✔





259












260



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




1✔





261



        ASSERT_EQ(lower, 123ULL);




1✔





262



        ASSERT_EQ(upper, 111ULL);




1✔





263












264



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




1✔





265



        ASSERT_EQ(lower, 123ULL);




1✔





266



        ASSERT_EQ(upper, 123ULL);




1✔





267












268



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




1✔





269



        ASSERT_EQ(lower, 0ULL);




1✔





270



        ASSERT_EQ(upper, 0ULL);




1✔





271












272



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




1✔





273



        ASSERT_EQ(lower, 0ULL);




1✔





274



        ASSERT_EQ(upper, 15ULL);




1✔





275












276



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




1✔





277



        ASSERT_EQ(lower, 15ULL);




1✔





278



        ASSERT_EQ(upper, 0ULL);




1✔





279












280



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




1✔





281



        ASSERT_EQ(lower, 128ULL);




1✔





282



        ASSERT_EQ(upper, 65535ULL);




1✔





283












284



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




1✔





285



        ASSERT_EQ(lower, 1024ULL);




1✔





286



        ASSERT_EQ(upper, 4294967295ULL);




1✔





287












288



        /* Leading whitespace is acceptable */










289



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




1✔





290



        ASSERT_EQ(lower, 111ULL);




1✔





291



        ASSERT_EQ(upper, 111ULL);




1✔





292












293



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




1✔





294



        ASSERT_EQ(lower, 111ULL);




1✔





295



        ASSERT_EQ(upper, 123ULL);




1✔





296












297



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




1✔





298



        ASSERT_EQ(lower, 111ULL);




1✔





299



        ASSERT_EQ(upper, 123ULL);




1✔





300












301



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




1✔





302



        ASSERT_EQ(lower, 111ULL);




1✔





303



        ASSERT_EQ(upper, 123ULL);




1✔





304












305



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




1✔





306



        ASSERT_EQ(lower, 111ULL);




1✔





307



        ASSERT_EQ(upper, 123ULL);




1✔





308












309



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










310



        lower = upper = 9999;




1✔





311



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




1✔





312



        ASSERT_EQ(lower, 9999ULL);




1✔





313



        ASSERT_EQ(upper, 9999ULL);




1✔





314












315



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




1✔





316



        ASSERT_EQ(lower, 9999ULL);




1✔





317



        ASSERT_EQ(upper, 9999ULL);




1✔





318












319



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




1✔





320



        ASSERT_EQ(lower, 9999ULL);




1✔





321



        ASSERT_EQ(upper, 9999ULL);




1✔





322












323



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




1✔





324



        ASSERT_EQ(lower, 9999ULL);




1✔





325



        ASSERT_EQ(upper, 9999ULL);




1✔





326












327



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




1✔





328



        ASSERT_EQ(lower, 9999ULL);




1✔





329



        ASSERT_EQ(upper, 9999ULL);




1✔





330












331



        /* Empty string */










332



        lower = upper = 9999;




1✔





333



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




1✔





334



        ASSERT_EQ(lower, 9999ULL);




1✔





335



        ASSERT_EQ(upper, 9999ULL);




1✔





336












337



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










338



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




1✔





339



        ASSERT_EQ(lower, 9999ULL);




1✔





340



        ASSERT_EQ(upper, 9999ULL);




1✔





341












342



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




1✔





343



        ASSERT_EQ(lower, 9999ULL);




1✔





344



        ASSERT_EQ(upper, 9999ULL);




1✔





345












346



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




1✔





347



        ASSERT_EQ(lower, 9999ULL);




1✔





348



        ASSERT_EQ(upper, 9999ULL);




1✔





349












350



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




1✔





351



        ASSERT_EQ(lower, 9999ULL);




1✔





352



        ASSERT_EQ(upper, 9999ULL);




1✔





353












354



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




1✔





355



        ASSERT_EQ(lower, 9999ULL);




1✔





356



        ASSERT_EQ(upper, 9999ULL);




1✔





357












358



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




1✔





359



        ASSERT_EQ(lower, 9999ULL);




1✔





360



        ASSERT_EQ(upper, 9999ULL);




1✔





361












362



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




1✔





363



        ASSERT_EQ(lower, 9999ULL);




1✔





364



        ASSERT_EQ(upper, 9999ULL);




1✔





365












366



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




1✔





367



        ASSERT_EQ(lower, 9999ULL);




1✔





368



        ASSERT_EQ(upper, 9999ULL);




1✔





369












370



        /* Error on trailing dash */










371



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




1✔





372



        ASSERT_EQ(lower, 9999ULL);




1✔





373



        ASSERT_EQ(upper, 9999ULL);




1✔





374












375



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




1✔





376



        ASSERT_EQ(lower, 9999ULL);




1✔





377



        ASSERT_EQ(upper, 9999ULL);




1✔





378












379



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




1✔





380



        ASSERT_EQ(lower, 9999ULL);




1✔





381



        ASSERT_EQ(upper, 9999ULL);




1✔





382












383



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




1✔





384



        ASSERT_EQ(lower, 9999ULL);




1✔





385



        ASSERT_EQ(upper, 9999ULL);




1✔





386












387



        /* Whitespace is not a separator */










388



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




1✔





389



        ASSERT_EQ(lower, 9999ULL);




1✔





390



        ASSERT_EQ(upper, 9999ULL);




1✔





391












392



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




1✔





393



        ASSERT_EQ(lower, 9999ULL);




1✔





394



        ASSERT_EQ(upper, 9999ULL);




1✔





395












396



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




1✔





397



        ASSERT_EQ(lower, 9999ULL);




1✔





398



        ASSERT_EQ(upper, 9999ULL);




1✔





399












400



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










401



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




1✔





402



        ASSERT_EQ(lower, 9999ULL);




1✔





403



        ASSERT_EQ(upper, 9999ULL);




1✔





404












405



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




1✔





406



        ASSERT_EQ(lower, 9999ULL);




1✔





407



        ASSERT_EQ(upper, 9999ULL);




1✔





408












409



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




1✔





410



        ASSERT_EQ(lower, 9999ULL);




1✔





411



        ASSERT_EQ(upper, 9999ULL);




1✔





412












413



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




1✔





414



        ASSERT_EQ(lower, 9999ULL);




1✔





415



        ASSERT_EQ(upper, 9999ULL);




1✔





416












417



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




1✔





418



        ASSERT_EQ(lower, 9999ULL);




1✔





419



        ASSERT_EQ(upper, 9999ULL);




1✔





420












421



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




1✔





422



        ASSERT_EQ(lower, 9999ULL);




1✔





423



        ASSERT_EQ(upper, 9999ULL);




1✔





424












425



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










426



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




1✔





427



        ASSERT_EQ(lower, 9999ULL);




1✔





428



        ASSERT_EQ(upper, 9999ULL);




1✔





429



}




1✔





430












431



TEST(safe_atou_bounded) {




1✔





432



        unsigned x;




1✔





433












434



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




1✔





435



        ASSERT_EQ(x, 12345ULL);




1✔





436












437



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




1✔





438



        ASSERT_EQ(x, 12ULL);




1✔





439












440



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




1✔





441



        ASSERT_EQ(x, 20000ULL);




1✔





442












443



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




1✔





444



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




1✔





445



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




1✔





446



}




1✔





447












448



TEST(safe_atolli) {




1✔





449



        long long l;




1✔





450












451



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




1✔





452



        ASSERT_EQ(l, 12345);




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("0x5", &l));




1✔





464



        ASSERT_EQ(l, 5);




1✔





465












466



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




1✔





467



        ASSERT_EQ(l, 6);




1✔





468












469



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




1✔





470



        ASSERT_EQ(l, 5);




1✔





471












472



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




1✔





473



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




1✔





474



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




1✔





475



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




1✔





476



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




1✔





477



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




1✔





478



}




1✔





479












480



TEST(safe_atou16) {




1✔





481



        uint16_t l;




1✔





482












483



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




1✔





484



        ASSERT_EQ(l, 12345);




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_ERROR(safe_atou16("123456", &l), ERANGE);




1✔





496



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




1✔





497



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




1✔





498



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




1✔





499



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




1✔





500



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




1✔





501



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




1✔





502



}




1✔





503












504



TEST(safe_atoi16) {




1✔





505



        int16_t l;




1✔





506












507



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




1✔





508



        ASSERT_EQ(l, -12345);




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("32767", &l));




1✔





520



        ASSERT_EQ(l, 32767);




1✔





521












522



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




1✔





523



        ASSERT_EQ(l, 32767);




1✔





524












525



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




1✔





526



        ASSERT_EQ(l, 9);




1✔





527












528



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




1✔





529



        ASSERT_EQ(l, 6);




1✔





530












531



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




1✔





532



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




1✔





533



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




1✔





534



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




1✔





535



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




1✔





536



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




1✔





537



}




1✔





538












539



TEST(safe_atoux16) {




1✔





540



        uint16_t l;




1✔





541












542



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




1✔





543



        ASSERT_EQ(l, 0x1234);




1✔





544












545



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




1✔





546



        ASSERT_EQ(l, 0xabcd);




1✔





547












548



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




1✔





549



        ASSERT_EQ(l, 0x1234);




1✔





550












551



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




1✔





552












553



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




1✔





554












555



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




1✔





556












557



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




1✔





558



        ASSERT_EQ(l, 177);




1✔





559












560



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




1✔





561



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




1✔





562



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




1✔





563



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




1✔





564



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




1✔





565



}




1✔





566












567



TEST(safe_atou64) {




1✔





568



        uint64_t l;




1✔





569












570



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




1✔





571



        ASSERT_EQ(l, 12345U);




1✔





572












573



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




1✔





574



        ASSERT_EQ(l, 12345U);




1✔





575












576



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




1✔





577



        ASSERT_EQ(l, 9U);




1✔





578












579



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




1✔





580



        ASSERT_EQ(l, 3U);




1✔





581












582



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




1✔





583



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




1✔





584



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




1✔





585



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




1✔





586



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




1✔





587



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




1✔





588



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




1✔





589



}




1✔





590












591



TEST(safe_atoi64) {




1✔





592



        int64_t l;




1✔





593












594



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




1✔





595



        ASSERT_EQ(l, -12345);




1✔





596












597



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




1✔





598



        ASSERT_EQ(l, -12345);




1✔





599












600



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




1✔





601



        ASSERT_EQ(l, 32767);




1✔





602












603



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




1✔





604



        ASSERT_EQ(l, 32767);




1✔





605












606



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




1✔





607



        ASSERT_EQ(l, 16);




1✔





608












609



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




1✔





610



        ASSERT_EQ(l, 10);




1✔





611












612



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




1✔





613



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




1✔





614



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




1✔





615



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




1✔





616



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




1✔





617



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




1✔





618



}




1✔





619












620



TEST(safe_atoux64) {




1✔





621



        uint64_t l;




1✔





622












623



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




1✔





624



        ASSERT_EQ(l, 0x12345U);




1✔





625












626



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




1✔





627



        ASSERT_EQ(l, 0x12345U);




1✔





628












629



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




1✔





630



        ASSERT_EQ(l, 0x12345U);




1✔





631












632



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




1✔





633



        ASSERT_EQ(l, 11603985U);




1✔





634












635



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




1✔





636



        ASSERT_EQ(l, 0x12345U);




1✔





637












638



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




1✔





639



        ASSERT_EQ(l, 0x12345U);




1✔





640












641



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




1✔





642



        ASSERT_EQ(l, 0x12345U);




1✔





643












644



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




1✔





645



        ASSERT_EQ(l, 11603985U);




1✔





646












647



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




1✔





648



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




1✔





649



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




1✔





650



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




1✔





651



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




1✔





652



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




1✔





653



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




1✔





654



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




1✔





655



}




1✔





656












657



TEST(safe_atod) {




1✔





658



        double d;




1✔





659












660



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




1✔





661












662



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




1✔





663



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




1✔





664












665



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




1✔





666



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




1✔





667












668



        /* Check if this really is locale independent */










669



        _cleanup_(freelocalep) locale_t loc =




×







670



                newlocale(LC_NUMERIC_MASK, "de_DE.utf8", (locale_t) 0);




1✔





671



        if (!loc)




1✔





672



                return (void) log_tests_skipped_errno(errno, "locale de_DE.utf8 not found");




1✔





673












674



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




×







675



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




×







676












677



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




×







678



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




×







679



}










680












681



TEST(parse_nice) {




1✔





682



        int n;




1✔





683












684



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




1✔





685



        ASSERT_EQ(n, 0);




1✔





686












687



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




1✔





688



        ASSERT_EQ(n, 0);




1✔





689












690



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




1✔





691



        ASSERT_EQ(n, -1);




1✔





692












693



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




1✔





694



        ASSERT_EQ(n, -2);




1✔





695












696



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




1✔





697



        ASSERT_EQ(n, 1);




1✔





698












699



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




1✔





700



        ASSERT_EQ(n, 2);




1✔





701












702



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




1✔





703



        ASSERT_EQ(n, 1);




1✔





704












705



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




1✔





706



        ASSERT_EQ(n, 2);




1✔





707












708



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




1✔





709



        ASSERT_EQ(n, -20);




1✔





710












711



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




1✔





712



        ASSERT_EQ(n, 19);




1✔





713












714



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




1✔





715



        ASSERT_EQ(n, 19);




1✔





716












717



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




1✔





718



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




1✔





719



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




1✔





720



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




1✔





721



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




1✔





722



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




1✔





723



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




1✔





724



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




1✔





725



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




1✔





726



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




1✔





727



}




1✔





728












729



TEST(parse_errno) {




1✔





730



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




1✔





731



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




1✔





732



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




1✔





733



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




1✔





734



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




1✔





735












736



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




1✔





737



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




1✔





738



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




1✔





739












740



        ASSERT_ERROR(parse_errno(""), EINVAL);




1✔





741



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




1✔





742



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




1✔





743



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




1✔





744



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




1✔





745



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




1✔





746



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




1✔





747



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




1✔





748



}




1✔





749












750



TEST(parse_fd) {




1✔





751



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




1✔





752



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




1✔





753












754



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




1✔





755



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




1✔





756












757



        ASSERT_ERROR(parse_fd(""), EINVAL);




1✔





758



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




1✔





759



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




1✔





760



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




1✔





761



}




1✔





762












763



TEST(parse_mtu) {




1✔





764



        uint32_t mtu = 0;




1✔





765












766



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




1✔





767



        ASSERT_EQ(mtu, 1500U);




1✔





768












769



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




1✔





770



        ASSERT_EQ(mtu, 1400U);




1✔





771












772



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




1✔





773



        ASSERT_EQ(mtu, 65535U);




1✔





774












775



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




1✔





776



        ASSERT_EQ(mtu, 65536U);




1✔





777












778



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




1✔





779



        ASSERT_EQ(mtu, 4294967295U);




1✔





780












781



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




1✔





782



        ASSERT_EQ(mtu, 500U);




1✔





783












784



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




1✔





785



        ASSERT_EQ(mtu, 1280U);




1✔





786












787



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




1✔





788












789



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




1✔





790



        ASSERT_EQ(mtu, 68U);




1✔





791












792



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




1✔





793



        ASSERT_EQ(mtu, 67U);




1✔





794












795



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




1✔





796



        ASSERT_EQ(mtu, 0U);




1✔





797












798



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




1✔





799












800



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




1✔





801



        ASSERT_EQ(mtu, 1500U);




1✔





802












803



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




1✔





804



        ASSERT_EQ(mtu, 1400U);




1✔





805












806



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




1✔





807



        ASSERT_EQ(mtu, 65535U);




1✔





808












809



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




1✔





810



        ASSERT_EQ(mtu, 65536U);




1✔





811












812



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




1✔





813



        ASSERT_EQ(mtu, 4294967295U);




1✔





814












815



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




1✔





816



        ASSERT_EQ(mtu, 500U);




1✔





817












818



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




1✔





819



        ASSERT_EQ(mtu, 1280U);




1✔





820












821



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




1✔





822












823



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




1✔





824



        ASSERT_EQ(mtu, 68U);




1✔





825












826



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




1✔





827



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




1✔





828



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




1✔





829












830



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




1✔





831



        ASSERT_EQ(mtu, 1280U);




1✔





832












833



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




1✔





834



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




1✔





835



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




1✔





836



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




1✔





837



}




1✔





838












839



TEST(parse_loadavg_fixed_point) {




1✔





840



        loadavg_t fp;




1✔





841












842



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




1✔





843



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 1U);




1✔





844



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 23U);




1✔





845












846



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




1✔





847



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 1U);




1✔





848



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 80U);




1✔





849












850



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




1✔





851



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 0U);




1✔





852



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 7U);




1✔





853












854



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




1✔





855



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 0U);




1✔





856



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 0U);




1✔





857












858



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




1✔





859



        ASSERT_EQ(LOADAVG_INT_SIDE(fp), 4096U);




1✔





860



        ASSERT_EQ(LOADAVG_DECIMAL_SIDE(fp), 57U);




1✔





861












862



        /* Caps out at 2 digit fracs */










863



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




1✔





864












865



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




1✔





866



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




1✔





867



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




1✔





868



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




1✔





869



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




1✔





870



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




1✔





871



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




1✔





872



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




1✔





873



}




1✔





874












875



TEST(nft_identifier_valid) {




1✔





876



        ASSERT_TRUE(nft_identifier_valid("a"));




1✔





877



        ASSERT_TRUE(nft_identifier_valid("abc"));




1✔





878



        ASSERT_TRUE(nft_identifier_valid("abc"));




1✔





879



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




1✔





880












881



        ASSERT_FALSE(nft_identifier_valid(NULL));




1✔





882



        ASSERT_FALSE(nft_identifier_valid(""));




1✔





883



        ASSERT_FALSE(nft_identifier_valid("1234"));




1✔





884



        ASSERT_FALSE(nft_identifier_valid("1xyz"));




1✔





885



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




1✔





886












887



        char s[NFT_NAME_MAXLEN+1];




1✔





888



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




1✔





889



        ASSERT_FALSE(nft_identifier_valid(s));




1✔





890



}




1✔





891












892



static uint64_t make_cap(int cap) {




4✔





893



        return ((uint64_t) 1ULL << (uint64_t) cap);




4✔





894



}










895












896



TEST(parse_capability_set) {




1✔





897



        uint64_t current;




1✔





898












899



        /* Empty string resets to CAP_MASK_UNSET */










900



        current = 0x1234;




1✔





901



        ASSERT_OK(parse_capability_set("", CAP_MASK_UNSET, &current));




1✔





902



        ASSERT_EQ(current, CAP_MASK_UNSET);




1✔





903












904



        /* Single capability by name - replaces if current == initial */










905



        current = CAP_MASK_UNSET;




1✔





906



        ASSERT_OK(parse_capability_set("cap_chown", CAP_MASK_UNSET, &current));




1✔





907



        ASSERT_EQ(current, make_cap(CAP_CHOWN));




1✔





908












909



        /* Single capability by name - merges if current != initial */










910



        current = make_cap(CAP_SETUID);




1✔





911



        ASSERT_OK(parse_capability_set("cap_chown", CAP_MASK_UNSET, &current));




1✔





912



        ASSERT_EQ(current, make_cap(CAP_CHOWN) | make_cap(CAP_SETUID));




1✔





913












914



        /* Multiple capabilities - replaces when current == initial */










915



        current = CAP_MASK_UNSET;




1✔





916



        ASSERT_OK(parse_capability_set("cap_chown cap_setuid", CAP_MASK_UNSET, &current));




1✔





917



        ASSERT_EQ(current, make_cap(CAP_CHOWN) | make_cap(CAP_SETUID));




1✔





918












919



        /* Multiple capabilities - merges when current != initial */










920



        current = make_cap(CAP_SETGID);




1✔





921



        ASSERT_OK(parse_capability_set("cap_chown cap_setuid", CAP_MASK_UNSET, &current));




1✔





922



        ASSERT_EQ(current, make_cap(CAP_CHOWN) | make_cap(CAP_SETUID) | make_cap(CAP_SETGID));




1✔





923












924



        /* Inverted capabilities - replaces with complement when current == initial */










925



        current = CAP_MASK_UNSET;




1✔





926



        ASSERT_OK(parse_capability_set("~cap_chown", CAP_MASK_UNSET, &current));




1✔





927



        ASSERT_EQ(current, all_capabilities() & ~make_cap(CAP_CHOWN));




1✔





928












929



        /* Inverted capabilities - removes from current when current != initial */










930



        current = all_capabilities();




1✔





931



        ASSERT_OK(parse_capability_set("~cap_chown", CAP_MASK_UNSET, &current));




1✔





932



        ASSERT_EQ(current, all_capabilities() & ~make_cap(CAP_CHOWN));




1✔





933












934



        /* Inverted multiple capabilities */










935



        current = all_capabilities();




1✔





936



        ASSERT_OK(parse_capability_set("~cap_chown cap_setuid", CAP_MASK_UNSET, &current));




1✔





937



        ASSERT_EQ(current, all_capabilities() & ~(make_cap(CAP_CHOWN) | make_cap(CAP_SETUID)));




1✔





938












939



        /* Tilde alone resets to all capabilities complement (i.e., empty) */










940



        current = 0x1234;




1✔





941



        ASSERT_OK(parse_capability_set("~", CAP_MASK_UNSET, &current));




1✔





942



        ASSERT_EQ(current, all_capabilities());




1✔





943












944



        /* Sequential calls - testing merge behavior */










945



        current = CAP_MASK_UNSET;




1✔





946



        ASSERT_OK(parse_capability_set("cap_chown", CAP_MASK_UNSET, &current));




1✔





947



        ASSERT_EQ(current, make_cap(CAP_CHOWN));




1✔





948



        ASSERT_OK(parse_capability_set("cap_setuid", CAP_MASK_UNSET, &current));




1✔





949



        ASSERT_EQ(current, make_cap(CAP_CHOWN) | make_cap(CAP_SETUID));




1✔





950












951



        /* Sequential calls with invert */










952



        current = all_capabilities();




1✔





953



        ASSERT_OK(parse_capability_set("~cap_chown", CAP_MASK_UNSET, &current));




1✔





954



        ASSERT_OK(parse_capability_set("~cap_setuid", CAP_MASK_UNSET, &current));




1✔





955



        ASSERT_EQ(current, all_capabilities() & ~(make_cap(CAP_CHOWN) | make_cap(CAP_SETUID)));




1✔





956












957



        /* Numeric capability */










958



        current = CAP_MASK_UNSET;




1✔





959



        ASSERT_OK(parse_capability_set("0", CAP_MASK_UNSET, &current));




1✔





960



        ASSERT_EQ(current, make_cap(0));




1✔





961












962



        current = CAP_MASK_UNSET;




1✔





963



        ASSERT_OK(parse_capability_set("5", CAP_MASK_UNSET, &current));




1✔





964



        ASSERT_EQ(current, make_cap(5));




1✔





965












966



        /* Mixed numeric and named capabilities */










967



        current = CAP_MASK_UNSET;




1✔





968



        ASSERT_OK(parse_capability_set("0 cap_chown 5", CAP_MASK_UNSET, &current));




1✔





969



        ASSERT_EQ(current, make_cap(0) | make_cap(CAP_CHOWN) | make_cap(5));




1✔





970












971



        /* Invalid capabilities are ignored but function returns 0 */










972



        current = CAP_MASK_UNSET;




1✔





973



        ASSERT_OK_ZERO(parse_capability_set("invalid_cap", CAP_MASK_UNSET, &current));




1✔





974



        ASSERT_EQ(current, 0U);




1✔





975












976



        /* Mix of valid and invalid capabilities */










977



        current = CAP_MASK_UNSET;




1✔





978



        ASSERT_OK_ZERO(parse_capability_set("cap_chown invalid_cap cap_setuid", CAP_MASK_UNSET, &current));




1✔





979



        ASSERT_EQ(current, make_cap(CAP_CHOWN) | make_cap(CAP_SETUID));




1✔





980












981



        /* Case insensitivity */










982



        current = CAP_MASK_UNSET;




1✔





983



        ASSERT_OK(parse_capability_set("CAP_CHOWN", CAP_MASK_UNSET, &current));




1✔





984



        ASSERT_EQ(current, make_cap(CAP_CHOWN));




1✔





985












986



        current = CAP_MASK_UNSET;




1✔





987



        ASSERT_OK(parse_capability_set("CaP_ChOwN", CAP_MASK_UNSET, &current));




1✔





988



        ASSERT_EQ(current, make_cap(CAP_CHOWN));




1✔





989












990



        /* Inverted with invalid capabilities */










991



        current = all_capabilities();




1✔





992



        ASSERT_OK_ZERO(parse_capability_set("~invalid_cap", CAP_MASK_UNSET, &current));




1✔





993



        ASSERT_EQ(current, all_capabilities());




1✔





994












995



        /* Inverted with mix of valid and invalid */










996



        current = all_capabilities();




1✔





997



        ASSERT_OK_ZERO(parse_capability_set("~cap_chown invalid_cap", CAP_MASK_UNSET, &current));




1✔





998



        ASSERT_EQ(current, all_capabilities() & ~make_cap(CAP_CHOWN));




1✔





999












1000



        /* Whitespace handling */










1001



        current = 0;




1✔





1002



        ASSERT_OK(parse_capability_set("  cap_chown   cap_setuid  ", CAP_MASK_UNSET, &current));




1✔





1003



        ASSERT_EQ(current, make_cap(CAP_CHOWN) | make_cap(CAP_SETUID));




1✔





1004












1005



        /* Testing that initial value determines replace vs merge */










1006



        current = make_cap(CAP_SETGID);




1✔





1007



        ASSERT_OK(parse_capability_set("cap_chown", make_cap(CAP_SETGID), &current));




1✔





1008



        ASSERT_EQ(current, make_cap(CAP_CHOWN)); /* Replace because current == initial */




1✔





1009












1010



        current = make_cap(CAP_SETGID);




1✔





1011



        ASSERT_OK(parse_capability_set("cap_chown", CAP_MASK_UNSET, &current));




1✔





1012



        ASSERT_EQ(current, make_cap(CAP_CHOWN) | make_cap(CAP_SETGID)); /* Merge because current != initial */




1✔





1013



}




1✔





1014












1015



DEFINE_TEST_MAIN(LOG_INFO);




1✔



















    

  • 

    •