tests: reformat unit test files with clang-format

4 files changed, 108 insertions, 100 deletions

diff --git a/tests/check-direct.c b/tests/check-direct.c
index 9080369..f40bcee 100644
--- a/tests/check-direct.c
+++ b/tests/check-direct.c
@@ -14,21 +14,24 @@ START_TEST(static_checks)
 	char strbuf[100];
 
 	_NL_STATIC_ASSERT(RTNL_LINK_RX_PACKETS == 0);
-	assert(_nltst_map_stat_id_from_IPSTATS_MIB_v2[0] == RTNL_LINK_RX_PACKETS);
+	assert(_nltst_map_stat_id_from_IPSTATS_MIB_v2[0] ==
+	       RTNL_LINK_RX_PACKETS);
 	for (i = 1; i < __IPSTATS_MIB_MAX; i++) {
 		assert(_nltst_map_stat_id_from_IPSTATS_MIB_v2[i] > 0);
-		assert(_nltst_map_stat_id_from_IPSTATS_MIB_v2[i] < __RTNL_LINK_STATS_MAX);
+		assert(_nltst_map_stat_id_from_IPSTATS_MIB_v2[i] <
+		       __RTNL_LINK_STATS_MAX);
 		for (j = 1; j < i; j++)
-			assert(_nltst_map_stat_id_from_IPSTATS_MIB_v2[i] != _nltst_map_stat_id_from_IPSTATS_MIB_v2[j]);
+			assert(_nltst_map_stat_id_from_IPSTATS_MIB_v2[i] !=
+			       _nltst_map_stat_id_from_IPSTATS_MIB_v2[j]);
 	}
 
 	for (i = 0; i <= RTNL_LINK_STATS_MAX + 1; i++) {
 		const char *s;
 
 		s = rtnl_link_stat2str(i, strbuf, sizeof(strbuf));
-		assert (s);
-		assert (s == strbuf);
-		assert (strlen (s) < sizeof(strbuf));
+		assert(s);
+		assert(s == strbuf);
+		assert(strlen(s) < sizeof(strbuf));
 		if (strncmp(s, "0x", 2) == 0) {
 			assert(i == RTNL_LINK_STATS_MAX + 1);
 			ck_assert_int_eq(strtoll(&s[2], NULL, 16), i);
diff --git a/tests/cksuite-all-addr.c b/tests/cksuite-all-addr.c
index 3f95821..f395351 100644
--- a/tests/cksuite-all-addr.c
+++ b/tests/cksuite-all-addr.c
@@ -14,34 +14,34 @@ START_TEST(addr_alloc)
 	struct nl_addr *addr;
 
 	addr = nl_addr_alloc(16);
-	ck_assert_msg(addr,
-		"Allocation should not return NULL");
+	ck_assert_msg(addr, "Allocation should not return NULL");
 
 	ck_assert_msg(nl_addr_iszero(addr) != 0,
-		"New empty address should be all zeros");
+		      "New empty address should be all zeros");
 
 	ck_assert_msg(nl_addr_get_family(addr) == AF_UNSPEC,
-		"New empty address should have family AF_UNSPEC");
+		      "New empty address should have family AF_UNSPEC");
 
 	ck_assert_msg(nl_addr_get_prefixlen(addr) == 0,
-		"New empty address should have prefix length 0");
+		      "New empty address should have prefix length 0");
 
 	ck_assert_msg(!nl_addr_shared(addr),
-		"New empty address should not be shared");
+		      "New empty address should not be shared");
 
 	ck_assert_msg(nl_addr_get(addr) == addr,
-		"nl_addr_get() should return pointer to address");
+		      "nl_addr_get() should return pointer to address");
 
 	ck_assert_msg(nl_addr_shared(addr) != 0,
-		"Address should be shared after call to nl_addr_get()");
+		      "Address should be shared after call to nl_addr_get()");
 
 	nl_addr_put(addr);
 
-	ck_assert_msg(!nl_addr_shared(addr),
+	ck_assert_msg(
+		!nl_addr_shared(addr),
 		"Address should not be shared after call to nl_addr_put()");
 
 	ck_assert_msg(nl_addr_fill_sockaddr(addr, NULL, 0) != 0,
-		"Socket address filling should fail for empty address");
+		      "Socket address filling should fail for empty address");
 
 	nl_addr_put(addr);
 }
@@ -54,40 +54,41 @@ START_TEST(addr_binary_addr)
 	char baddr2[6] = { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6 };
 
 	addr = nl_addr_alloc(4);
-	ck_assert_msg(addr != NULL,
-		"Allocation should not return NULL");
+	ck_assert_msg(addr != NULL, "Allocation should not return NULL");
 
 	ck_assert_msg(nl_addr_set_binary_addr(addr, baddr, 4) >= 0,
-		"Valid binary address should be settable");
+		      "Valid binary address should be settable");
 
-	ck_assert_msg(nl_addr_get_prefixlen(addr) == 0,
+	ck_assert_msg(
+		nl_addr_get_prefixlen(addr) == 0,
 		"Prefix length should be unchanged after nl_addr_set_binary_addr()");
 
-	ck_assert_msg(nl_addr_get_len(addr) == 4,
-		"Address length should be 4");
+	ck_assert_msg(nl_addr_get_len(addr) == 4, "Address length should be 4");
 
-	ck_assert_msg(nl_addr_set_binary_addr(addr, baddr2, 6) != 0,
+	ck_assert_msg(
+		nl_addr_set_binary_addr(addr, baddr2, 6) != 0,
 		"Should not be able to set binary address exceeding maximum length");
 
 	ck_assert_msg(nl_addr_get_len(addr) == 4,
-		"Address length should still be 4");
+		      "Address length should still be 4");
 
-	ck_assert_msg(nl_addr_guess_family(addr) == AF_INET,
+	ck_assert_msg(
+		nl_addr_guess_family(addr) == AF_INET,
 		"Binary address of length 4 should be guessed as AF_INET");
 
 	ck_assert_msg(memcmp(baddr, nl_addr_get_binary_addr(addr), 4) == 0,
-		"Binary address mismatches");
+		      "Binary address mismatches");
 
 	addr2 = nl_addr_build(AF_UNSPEC, baddr, 4);
-	ck_assert_msg(addr2 != NULL,
-		"Building of address should not fail");
+	ck_assert_msg(addr2 != NULL, "Building of address should not fail");
 
 	nl_addr_set_prefixlen(addr, 32);
-	ck_assert_msg(nl_addr_get_prefixlen(addr) == 32,
+	ck_assert_msg(
+		nl_addr_get_prefixlen(addr) == 32,
 		"Prefix length should be successful changed after nl_addr_set_prefixlen()");
 
 	ck_assert_msg(!nl_addr_cmp(addr, addr2),
-		"Addresses built from same binary address should match");
+		      "Addresses built from same binary address should match");
 
 	nl_addr_put(addr);
 	nl_addr_put(addr2);
@@ -103,31 +104,32 @@ START_TEST(addr_parse4)
 	char buf[128];
 
 	ck_assert_msg(nl_addr_parse(addr_str, AF_INET6, &addr4) != 0,
-		"Should not be able to parse IPv4 address in IPv6 mode");
+		      "Should not be able to parse IPv4 address in IPv6 mode");
 
 	ck_assert_msg(nl_addr_parse(addr_str, AF_UNSPEC, &addr4) == 0,
-		"Should be able to parse \"%s\"", addr_str);
+		      "Should be able to parse \"%s\"", addr_str);
 
 	ck_assert_msg(nl_addr_get_family(addr4) == AF_INET,
-		"Address family should be AF_INET");
+		      "Address family should be AF_INET");
 
 	ck_assert_msg(nl_addr_get_prefixlen(addr4) == 16,
-		"Prefix length should be 16");
+		      "Prefix length should be 16");
 
 	ck_assert_msg(!nl_addr_iszero(addr4),
-		"Address should not be all zeroes");
+		      "Address should not be all zeroes");
 
 	clone = nl_addr_clone(addr4);
-	ck_assert_msg(clone != NULL,
-		"Cloned address should not be NULL");
+	ck_assert_msg(clone != NULL, "Cloned address should not be NULL");
 
 	ck_assert_msg(nl_addr_cmp(addr4, clone) == 0,
-		"Cloned address should not mismatch original");
+		      "Cloned address should not mismatch original");
 
-	ck_assert_msg(nl_addr_fill_sockaddr(addr4, (struct sockaddr *) &sin, &len) == 0,
-		"Should be able to fill socketaddr");
+	ck_assert_msg(nl_addr_fill_sockaddr(addr4, (struct sockaddr *)&sin,
+					    &len) == 0,
+		      "Should be able to fill socketaddr");
 
-	ck_assert_msg(!strcmp(nl_addr2str(addr4, buf, sizeof(buf)), addr_str),
+	ck_assert_msg(
+		!strcmp(nl_addr2str(addr4, buf, sizeof(buf)), addr_str),
 		"Address translated back to string does not match original");
 
 	nl_addr_put(addr4);
@@ -144,31 +146,32 @@ START_TEST(addr_parse6)
 	char buf[128];
 
 	ck_assert_msg(nl_addr_parse(addr_str, AF_INET, &addr6) != 0,
-		"Should not be able to parse IPv6 address in IPv4 mode");
+		      "Should not be able to parse IPv6 address in IPv4 mode");
 
 	ck_assert_msg(nl_addr_parse(addr_str, AF_UNSPEC, &addr6) == 0,
-		"Should be able to parse \"%s\"", addr_str);
+		      "Should be able to parse \"%s\"", addr_str);
 
 	ck_assert_msg(nl_addr_get_family(addr6) == AF_INET6,
-		"Address family should be AF_INET6");
+		      "Address family should be AF_INET6");
 
 	ck_assert_msg(nl_addr_get_prefixlen(addr6) == 64,
-		"Prefix length should be 64");
+		      "Prefix length should be 64");
 
 	ck_assert_msg(!nl_addr_iszero(addr6),
-		"Address should not be all zeroes");
+		      "Address should not be all zeroes");
 
 	clone = nl_addr_clone(addr6);
-	ck_assert_msg(clone != NULL,
-		"Cloned address should not be NULL");
+	ck_assert_msg(clone != NULL, "Cloned address should not be NULL");
 
 	ck_assert_msg(nl_addr_cmp(addr6, clone) == 0,
-		"Cloned address should not mismatch original");
+		      "Cloned address should not mismatch original");
 
-	ck_assert_msg(nl_addr_fill_sockaddr(addr6, (struct sockaddr *) &sin, &len) == 0,
-		"Should be able to fill socketaddr");
+	ck_assert_msg(nl_addr_fill_sockaddr(addr6, (struct sockaddr *)&sin,
+					    &len) == 0,
+		      "Should be able to fill socketaddr");
 
-	ck_assert_msg(!strcmp(nl_addr2str(addr6, buf, sizeof(buf)), addr_str),
+	ck_assert_msg(
+		!strcmp(nl_addr2str(addr6, buf, sizeof(buf)), addr_str),
 		"Address translated back to string does not match original");
 
 	nl_addr_put(addr6);
@@ -183,10 +186,10 @@ START_TEST(addr_info)
 	struct addrinfo *result;
 
 	ck_assert_msg(nl_addr_parse(addr_str, AF_UNSPEC, &addr) == 0,
-		"Parsing of valid address should not fail");
+		      "Parsing of valid address should not fail");
 
 	ck_assert_msg(nl_addr_info(addr, &result) == 0,
-		"getaddrinfo() on loopback address should work");
+		      "getaddrinfo() on loopback address should work");
 
 	freeaddrinfo(result);
 	nl_addr_put(addr);
diff --git a/tests/cksuite-all-attr.c b/tests/cksuite-all-attr.c
index ca6f7c2..3b511f6 100644
--- a/tests/cksuite-all-attr.c
+++ b/tests/cksuite-all-attr.c
@@ -16,35 +16,35 @@
 START_TEST(attr_size)
 {
 	ck_assert_msg(nla_attr_size(0) == NLA_HDRLEN,
-		"Length of empty attribute should match header size");
+		      "Length of empty attribute should match header size");
 	ck_assert_msg(nla_attr_size(1) == NLA_HDRLEN + 1,
-	        "Length of 1 bytes payload should be NLA_HDRLEN + 1");
+		      "Length of 1 bytes payload should be NLA_HDRLEN + 1");
 	ck_assert_msg(nla_attr_size(2) == NLA_HDRLEN + 2,
-	        "Length of 2 bytes payload should be NLA_HDRLEN + 2");
+		      "Length of 2 bytes payload should be NLA_HDRLEN + 2");
 	ck_assert_msg(nla_attr_size(3) == NLA_HDRLEN + 3,
-	        "Length of 3 bytes payload should be NLA_HDRLEN + 3");
+		      "Length of 3 bytes payload should be NLA_HDRLEN + 3");
 	ck_assert_msg(nla_attr_size(4) == NLA_HDRLEN + 4,
-	        "Length of 4 bytes payload should be NLA_HDRLEN + 4");
+		      "Length of 4 bytes payload should be NLA_HDRLEN + 4");
 
 	ck_assert_msg(nla_total_size(1) == NLA_HDRLEN + 4,
-		"Total size of 1 bytes payload should result in 8 bytes");
+		      "Total size of 1 bytes payload should result in 8 bytes");
 	ck_assert_msg(nla_total_size(2) == NLA_HDRLEN + 4,
-		"Total size of 2 bytes payload should result in 8 bytes");
+		      "Total size of 2 bytes payload should result in 8 bytes");
 	ck_assert_msg(nla_total_size(3) == NLA_HDRLEN + 4,
-		"Total size of 3 bytes payload should result in 8 bytes");
+		      "Total size of 3 bytes payload should result in 8 bytes");
 	ck_assert_msg(nla_total_size(4) == NLA_HDRLEN + 4,
-		"Total size of 4 bytes payload should result in 8 bytes");
+		      "Total size of 4 bytes payload should result in 8 bytes");
 
 	ck_assert_msg(nla_padlen(1) == 3,
-		"2 bytes of payload should result in 3 padding bytes");
+		      "2 bytes of payload should result in 3 padding bytes");
 	ck_assert_msg(nla_padlen(2) == 2,
-		"2 bytes of payload should result in 2 padding bytes");
+		      "2 bytes of payload should result in 2 padding bytes");
 	ck_assert_msg(nla_padlen(3) == 1,
-		"3 bytes of payload should result in 1 padding bytes");
+		      "3 bytes of payload should result in 1 padding bytes");
 	ck_assert_msg(nla_padlen(4) == 0,
-		"4 bytes of payload should result in 0 padding bytes");
+		      "4 bytes of payload should result in 0 padding bytes");
 	ck_assert_msg(nla_padlen(5) == 3,
-		"5 bytes of payload should result in 3 padding bytes");
+		      "5 bytes of payload should result in 3 padding bytes");
 }
 END_TEST
 
@@ -59,16 +59,17 @@ START_TEST(msg_construct)
 	ck_assert_msg(msg, "Unable to allocate netlink message");
 
 	for (i = 1; i < 256; i++) {
-		ck_assert_msg(nla_put_u32(msg, i, i+1) == 0,
-			"Unable to add attribute %d", i);
+		ck_assert_msg(nla_put_u32(msg, i, i + 1) == 0,
+			      "Unable to add attribute %d", i);
 	}
 
 	nlh = nlmsg_hdr(msg);
 	i = 1;
-	nlmsg_for_each_attr(a, nlh, 0, rem) {
+	nlmsg_for_each_attr (a, nlh, 0, rem) {
 		ck_assert_msg(nla_type(a) == i, "Expected attribute %d", i);
 		i++;
-		ck_assert_msg(nla_get_u32(a) == i, "Expected attribute value %d", i);
+		ck_assert_msg(nla_get_u32(a) == i,
+			      "Expected attribute value %d", i);
 	}
 
 	nlmsg_free(msg);
@@ -77,42 +78,42 @@ END_TEST
 
 START_TEST(clone_cls_u32)
 {
-    _nl_auto_rtnl_link struct rtnl_link *link = NULL;
-    _nl_auto_rtnl_cls struct rtnl_cls *cls = NULL;
-    _nl_auto_rtnl_cls struct rtnl_cls *cls2 = NULL;
-    int r;
-    const uint32_t direction = 16;
+	_nl_auto_rtnl_link struct rtnl_link *link = NULL;
+	_nl_auto_rtnl_cls struct rtnl_cls *cls = NULL;
+	_nl_auto_rtnl_cls struct rtnl_cls *cls2 = NULL;
+	int r;
+	const uint32_t direction = 16;
 
-    link = rtnl_link_alloc();
-    ck_assert(link);
+	link = rtnl_link_alloc();
+	ck_assert(link);
 
-    rtnl_link_set_ifindex(link, 5);
+	rtnl_link_set_ifindex(link, 5);
 
-    cls = rtnl_cls_alloc();
-    ck_assert(cls);
+	cls = rtnl_cls_alloc();
+	ck_assert(cls);
 
-    rtnl_tc_set_link(TC_CAST(cls), link);
+	rtnl_tc_set_link(TC_CAST(cls), link);
 
-    r = rtnl_tc_set_kind(TC_CAST(cls), "u32");
-    ck_assert(r == 0);
+	r = rtnl_tc_set_kind(TC_CAST(cls), "u32");
+	ck_assert(r == 0);
 
-    rtnl_cls_set_prio(cls, 1);
-    rtnl_cls_set_protocol(cls, ETH_P_IP);
+	rtnl_cls_set_prio(cls, 1);
+	rtnl_cls_set_protocol(cls, ETH_P_IP);
 
-    rtnl_tc_set_parent(TC_CAST(cls), TC_HANDLE(1, 0));
+	rtnl_tc_set_parent(TC_CAST(cls), TC_HANDLE(1, 0));
 
-    rtnl_u32_set_hashtable(cls, 5);
+	rtnl_u32_set_hashtable(cls, 5);
 
-    rtnl_u32_add_key_uint32(cls,  0x0a000914, 0xffffffff, direction, 0);
+	rtnl_u32_add_key_uint32(cls, 0x0a000914, 0xffffffff, direction, 0);
 
-    rtnl_u32_set_hashmask(cls, 0xff000000, direction);
+	rtnl_u32_set_hashmask(cls, 0xff000000, direction);
 
-    rtnl_u32_add_mark(cls, 55, 66);
+	rtnl_u32_add_mark(cls, 55, 66);
 
-    rtnl_u32_set_link(cls, 44);
+	rtnl_u32_set_link(cls, 44);
 
-    cls2 = (struct rtnl_cls *)nl_object_clone((struct nl_object *)cls);
-    ck_assert(cls2);
+	cls2 = (struct rtnl_cls *)nl_object_clone((struct nl_object *)cls);
+	ck_assert(cls2);
 }
 END_TEST
 
diff --git a/tests/cksuite-all-ematch-tree-clone.c b/tests/cksuite-all-ematch-tree-clone.c
index eb38e99..f9d17a9 100644
--- a/tests/cksuite-all-ematch-tree-clone.c
+++ b/tests/cksuite-all-ematch-tree-clone.c
@@ -8,8 +8,8 @@
 #include "cksuite-all.h"
 #include "netlink-private/nl-auto.h"
 
-#define MAX_DEPTH		6
-#define MAX_CHILDREN		5
+#define MAX_DEPTH 6
+#define MAX_CHILDREN 5
 
 static int current_depth = 0;
 static int id = 1;
@@ -25,7 +25,7 @@ static long long my_pow(long long x, long long y)
 	if (y < 0 || x == 0)
 		return 0;
 
-	while(--y) {
+	while (--y) {
 		ret *= x;
 	}
 
@@ -76,7 +76,7 @@ static void dump_ematch_list(struct nl_list_head *head, int *result, int *index)
 {
 	struct rtnl_ematch *pos = NULL;
 
-	nl_list_for_each_entry(pos, head, e_list) {
+	nl_list_for_each_entry (pos, head, e_list) {
 		if (!nl_list_empty(&pos->e_childs))
 			dump_ematch_list(&pos->e_childs, result, index);
 		result[*index] = pos->e_id;
@@ -84,7 +84,8 @@ static void dump_ematch_list(struct nl_list_head *head, int *result, int *index)
 	}
 }
 
-static void dump_ematch_tree(struct rtnl_ematch_tree *tree, int *result, int *index)
+static void dump_ematch_tree(struct rtnl_ematch_tree *tree, int *result,
+			     int *index)
 {
 	if (!tree)
 		return;