From 59e0a258f9c0f393bf29cced1f35743f74e7b10c Mon Sep 17 00:00:00 2001
From: Lorenz Kästle <12514511+RincewindsHat@users.noreply.github.com>
Date: Tue, 18 Mar 2025 15:57:44 +0100
Subject: Migrate disk tests from lib, tool

---
 plugins/tests/test_check_disk.c | 192 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 192 insertions(+)
 create mode 100644 plugins/tests/test_check_disk.c

(limited to 'plugins/tests/test_check_disk.c')

diff --git a/plugins/tests/test_check_disk.c b/plugins/tests/test_check_disk.c
new file mode 100644
index 00000000..92d0d270
--- /dev/null
+++ b/plugins/tests/test_check_disk.c
@@ -0,0 +1,192 @@
+/*****************************************************************************
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *
+ *****************************************************************************/
+
+#include "common.h"
+#include "../check_disk.d/utils_disk.h"
+#include "../../tap/tap.h"
+#include "regex.h"
+
+void np_test_mount_entry_regex(struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc);
+
+int main(int argc, char **argv) {
+	struct name_list *exclude_filesystem = NULL;
+	struct name_list *exclude_fstype = NULL;
+	struct name_list *dummy_mountlist = NULL;
+	struct name_list *temp_name;
+	struct parameter_list *paths = NULL;
+	struct parameter_list *p, *prev = NULL, *last = NULL;
+
+	struct mount_entry *dummy_mount_list;
+	struct mount_entry *me;
+	struct mount_entry **mtail = &dummy_mount_list;
+	int cflags = REG_NOSUB | REG_EXTENDED;
+	int found = 0, count = 0;
+
+	plan_tests(33);
+
+	ok(np_find_name(exclude_filesystem, "/var/log") == false, "/var/log not in list");
+	np_add_name(&exclude_filesystem, "/var/log");
+	ok(np_find_name(exclude_filesystem, "/var/log") == true, "is in list now");
+	ok(np_find_name(exclude_filesystem, "/home") == false, "/home not in list");
+	np_add_name(&exclude_filesystem, "/home");
+	ok(np_find_name(exclude_filesystem, "/home") == true, "is in list now");
+	ok(np_find_name(exclude_filesystem, "/var/log") == true, "/var/log still in list");
+
+	ok(np_find_name(exclude_fstype, "iso9660") == false, "iso9660 not in list");
+	np_add_name(&exclude_fstype, "iso9660");
+	ok(np_find_name(exclude_fstype, "iso9660") == true, "is in list now");
+
+	ok(np_find_name(exclude_filesystem, "iso9660") == false, "Make sure no clashing in variables");
+
+	/*
+	for (temp_name = exclude_filesystem; temp_name; temp_name = temp_name->next) {
+		printf("Name: %s\n", temp_name->name);
+	}
+	*/
+
+	me = (struct mount_entry *)malloc(sizeof *me);
+	me->me_devname = strdup("/dev/c0t0d0s0");
+	me->me_mountdir = strdup("/");
+	*mtail = me;
+	mtail = &me->me_next;
+
+	me = (struct mount_entry *)malloc(sizeof *me);
+	me->me_devname = strdup("/dev/c1t0d1s0");
+	me->me_mountdir = strdup("/var");
+	*mtail = me;
+	mtail = &me->me_next;
+
+	me = (struct mount_entry *)malloc(sizeof *me);
+	me->me_devname = strdup("/dev/c2t0d0s0");
+	me->me_mountdir = strdup("/home");
+	*mtail = me;
+	mtail = &me->me_next;
+
+	np_test_mount_entry_regex(dummy_mount_list, strdup("/"), cflags, 3, strdup("a"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("/dev"), cflags, 3, strdup("regex on dev names:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("/foo"), cflags, 0, strdup("regex on non existent dev/path:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("/Foo"), cflags | REG_ICASE, 0, strdup("regi on non existent dev/path:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("/c.t0"), cflags, 3, strdup("partial devname regex match:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("c0t0"), cflags, 1, strdup("partial devname regex match:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("C0t0"), cflags | REG_ICASE, 1, strdup("partial devname regi match:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("home"), cflags, 1, strdup("partial pathname regex match:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("hOme"), cflags | REG_ICASE, 1, strdup("partial pathname regi match:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("(/home)|(/var)"), cflags, 2, strdup("grouped regex pathname match:"));
+	np_test_mount_entry_regex(dummy_mount_list, strdup("(/homE)|(/Var)"), cflags | REG_ICASE, 2, strdup("grouped regi pathname match:"));
+
+	np_add_parameter(&paths, "/home/groups");
+	np_add_parameter(&paths, "/var");
+	np_add_parameter(&paths, "/tmp");
+	np_add_parameter(&paths, "/home/tonvoon");
+	np_add_parameter(&paths, "/dev/c2t0d0s0");
+
+	np_set_best_match(paths, dummy_mount_list, false);
+	for (p = paths; p; p = p->name_next) {
+		struct mount_entry *temp_me;
+		temp_me = p->best_match;
+		if (!strcmp(p->name, "/home/groups")) {
+			ok(temp_me && !strcmp(temp_me->me_mountdir, "/home"), "/home/groups got right best match: /home");
+		} else if (!strcmp(p->name, "/var")) {
+			ok(temp_me && !strcmp(temp_me->me_mountdir, "/var"), "/var got right best match: /var");
+		} else if (!strcmp(p->name, "/tmp")) {
+			ok(temp_me && !strcmp(temp_me->me_mountdir, "/"), "/tmp got right best match: /");
+		} else if (!strcmp(p->name, "/home/tonvoon")) {
+			ok(temp_me && !strcmp(temp_me->me_mountdir, "/home"), "/home/tonvoon got right best match: /home");
+		} else if (!strcmp(p->name, "/dev/c2t0d0s0")) {
+			ok(temp_me && !strcmp(temp_me->me_devname, "/dev/c2t0d0s0"), "/dev/c2t0d0s0 got right best match: /dev/c2t0d0s0");
+		}
+	}
+
+	paths = NULL; /* Bad boy - should free, but this is a test suite */
+	np_add_parameter(&paths, "/home/groups");
+	np_add_parameter(&paths, "/var");
+	np_add_parameter(&paths, "/tmp");
+	np_add_parameter(&paths, "/home/tonvoon");
+	np_add_parameter(&paths, "/home");
+
+	np_set_best_match(paths, dummy_mount_list, true);
+	for (p = paths; p; p = p->name_next) {
+		if (!strcmp(p->name, "/home/groups")) {
+			ok(!p->best_match, "/home/groups correctly not found");
+		} else if (!strcmp(p->name, "/var")) {
+			ok(p->best_match, "/var found");
+		} else if (!strcmp(p->name, "/tmp")) {
+			ok(!p->best_match, "/tmp correctly not found");
+		} else if (!strcmp(p->name, "/home/tonvoon")) {
+			ok(!p->best_match, "/home/tonvoon not found");
+		} else if (!strcmp(p->name, "/home")) {
+			ok(p->best_match, "/home found");
+		}
+	}
+
+	/* test deleting first element in paths */
+	paths = np_del_parameter(paths, NULL);
+	for (p = paths; p; p = p->name_next) {
+		if (!strcmp(p->name, "/home/groups"))
+			found = 1;
+	}
+	ok(found == 0, "first element successfully deleted");
+	found = 0;
+
+	p = paths;
+	while (p) {
+		if (!strcmp(p->name, "/tmp"))
+			p = np_del_parameter(p, prev);
+		else {
+			prev = p;
+			p = p->name_next;
+		}
+	}
+
+	for (p = paths; p; p = p->name_next) {
+		if (!strcmp(p->name, "/tmp"))
+			found = 1;
+		if (p->name_next)
+			prev = p;
+		else
+			last = p;
+	}
+	ok(found == 0, "/tmp element successfully deleted");
+
+	p = np_del_parameter(last, prev);
+	for (p = paths; p; p = p->name_next) {
+		if (!strcmp(p->name, "/home"))
+			found = 1;
+		last = p;
+		count++;
+	}
+	ok(found == 0, "last (/home) element successfully deleted");
+	ok(count == 2, "two elements remaining");
+
+	return exit_status();
+}
+
+void np_test_mount_entry_regex(struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc) {
+	int matches = 0;
+	regex_t re;
+	struct mount_entry *me;
+	if (regcomp(&re, regstr, cflags) == 0) {
+		for (me = dummy_mount_list; me; me = me->me_next) {
+			if (np_regex_match_mount_entry(me, &re))
+				matches++;
+		}
+		ok(matches == expect, "%s '%s' matched %i/3 entries. ok: %i/3", desc, regstr, expect, matches);
+
+	} else
+		ok(false, "regex '%s' not compilable", regstr);
+}
-- 
cgit v1.2.3-74-g34f1


From 42531fa92a97318f2b96265f501f37e7fd96ea4c Mon Sep 17 00:00:00 2001
From: Lorenz Kästle <12514511+RincewindsHat@users.noreply.github.com>
Date: Tue, 18 Mar 2025 16:23:33 +0100
Subject: Refactor test_check_disk.c

---
 plugins/tests/test_check_disk.c | 86 +++++++++++++++++++++--------------------
 1 file changed, 44 insertions(+), 42 deletions(-)

(limited to 'plugins/tests/test_check_disk.c')

diff --git a/plugins/tests/test_check_disk.c b/plugins/tests/test_check_disk.c
index 92d0d270..963a9413 100644
--- a/plugins/tests/test_check_disk.c
+++ b/plugins/tests/test_check_disk.c
@@ -24,21 +24,9 @@
 void np_test_mount_entry_regex(struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc);
 
 int main(int argc, char **argv) {
-	struct name_list *exclude_filesystem = NULL;
-	struct name_list *exclude_fstype = NULL;
-	struct name_list *dummy_mountlist = NULL;
-	struct name_list *temp_name;
-	struct parameter_list *paths = NULL;
-	struct parameter_list *p, *prev = NULL, *last = NULL;
-
-	struct mount_entry *dummy_mount_list;
-	struct mount_entry *me;
-	struct mount_entry **mtail = &dummy_mount_list;
-	int cflags = REG_NOSUB | REG_EXTENDED;
-	int found = 0, count = 0;
-
 	plan_tests(33);
 
+	struct name_list *exclude_filesystem = NULL;
 	ok(np_find_name(exclude_filesystem, "/var/log") == false, "/var/log not in list");
 	np_add_name(&exclude_filesystem, "/var/log");
 	ok(np_find_name(exclude_filesystem, "/var/log") == true, "is in list now");
@@ -47,6 +35,7 @@ int main(int argc, char **argv) {
 	ok(np_find_name(exclude_filesystem, "/home") == true, "is in list now");
 	ok(np_find_name(exclude_filesystem, "/var/log") == true, "/var/log still in list");
 
+	struct name_list *exclude_fstype = NULL;
 	ok(np_find_name(exclude_fstype, "iso9660") == false, "iso9660 not in list");
 	np_add_name(&exclude_fstype, "iso9660");
 	ok(np_find_name(exclude_fstype, "iso9660") == true, "is in list now");
@@ -59,7 +48,9 @@ int main(int argc, char **argv) {
 	}
 	*/
 
-	me = (struct mount_entry *)malloc(sizeof *me);
+	struct mount_entry *dummy_mount_list;
+	struct mount_entry **mtail = &dummy_mount_list;
+	struct mount_entry *me = (struct mount_entry *)malloc(sizeof *me);
 	me->me_devname = strdup("/dev/c0t0d0s0");
 	me->me_mountdir = strdup("/");
 	*mtail = me;
@@ -77,6 +68,7 @@ int main(int argc, char **argv) {
 	*mtail = me;
 	mtail = &me->me_next;
 
+	int cflags = REG_NOSUB | REG_EXTENDED;
 	np_test_mount_entry_regex(dummy_mount_list, strdup("/"), cflags, 3, strdup("a"));
 	np_test_mount_entry_regex(dummy_mount_list, strdup("/dev"), cflags, 3, strdup("regex on dev names:"));
 	np_test_mount_entry_regex(dummy_mount_list, strdup("/foo"), cflags, 0, strdup("regex on non existent dev/path:"));
@@ -89,6 +81,7 @@ int main(int argc, char **argv) {
 	np_test_mount_entry_regex(dummy_mount_list, strdup("(/home)|(/var)"), cflags, 2, strdup("grouped regex pathname match:"));
 	np_test_mount_entry_regex(dummy_mount_list, strdup("(/homE)|(/Var)"), cflags | REG_ICASE, 2, strdup("grouped regi pathname match:"));
 
+	struct parameter_list *paths = NULL;
 	np_add_parameter(&paths, "/home/groups");
 	np_add_parameter(&paths, "/var");
 	np_add_parameter(&paths, "/tmp");
@@ -96,7 +89,7 @@ int main(int argc, char **argv) {
 	np_add_parameter(&paths, "/dev/c2t0d0s0");
 
 	np_set_best_match(paths, dummy_mount_list, false);
-	for (p = paths; p; p = p->name_next) {
+	for (struct parameter_list *p = paths; p; p = p->name_next) {
 		struct mount_entry *temp_me;
 		temp_me = p->best_match;
 		if (!strcmp(p->name, "/home/groups")) {
@@ -120,7 +113,7 @@ int main(int argc, char **argv) {
 	np_add_parameter(&paths, "/home");
 
 	np_set_best_match(paths, dummy_mount_list, true);
-	for (p = paths; p; p = p->name_next) {
+	for (struct parameter_list *p = paths; p; p = p->name_next) {
 		if (!strcmp(p->name, "/home/groups")) {
 			ok(!p->best_match, "/home/groups correctly not found");
 		} else if (!strcmp(p->name, "/var")) {
@@ -134,59 +127,68 @@ int main(int argc, char **argv) {
 		}
 	}
 
+	bool found = false;
 	/* test deleting first element in paths */
 	paths = np_del_parameter(paths, NULL);
-	for (p = paths; p; p = p->name_next) {
-		if (!strcmp(p->name, "/home/groups"))
-			found = 1;
+	for (struct parameter_list *p = paths; p; p = p->name_next) {
+		if (!strcmp(p->name, "/home/groups")) {
+			found = true;
+		}
 	}
-	ok(found == 0, "first element successfully deleted");
-	found = 0;
+	ok(!found, "first element successfully deleted");
+	found = false;
 
-	p = paths;
+	struct parameter_list *prev = NULL;
+	struct parameter_list *p = paths;
 	while (p) {
-		if (!strcmp(p->name, "/tmp"))
+		if (!strcmp(p->name, "/tmp")) {
 			p = np_del_parameter(p, prev);
-		else {
+		} else {
 			prev = p;
 			p = p->name_next;
 		}
 	}
 
-	for (p = paths; p; p = p->name_next) {
-		if (!strcmp(p->name, "/tmp"))
-			found = 1;
-		if (p->name_next)
-			prev = p;
-		else
-			last = p;
+	struct parameter_list *last = NULL;
+	for (struct parameter_list *path = paths; path; path = path->name_next) {
+		if (!strcmp(path->name, "/tmp")) {
+			found = true;
+		}
+		if (path->name_next) {
+			prev = path;
+		} else {
+			last = path;
+		}
 	}
-	ok(found == 0, "/tmp element successfully deleted");
+	ok(!found, "/tmp element successfully deleted");
 
+	int count = 0;
 	p = np_del_parameter(last, prev);
 	for (p = paths; p; p = p->name_next) {
-		if (!strcmp(p->name, "/home"))
-			found = 1;
+		if (!strcmp(p->name, "/home")) {
+			found = true;
+		}
 		last = p;
 		count++;
 	}
-	ok(found == 0, "last (/home) element successfully deleted");
+	ok(!found, "last (/home) element successfully deleted");
 	ok(count == 2, "two elements remaining");
 
 	return exit_status();
 }
 
 void np_test_mount_entry_regex(struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc) {
-	int matches = 0;
-	regex_t re;
-	struct mount_entry *me;
-	if (regcomp(&re, regstr, cflags) == 0) {
-		for (me = dummy_mount_list; me; me = me->me_next) {
-			if (np_regex_match_mount_entry(me, &re))
+	regex_t regex;
+	if (regcomp(&regex, regstr, cflags) == 0) {
+		int matches = 0;
+		for (struct mount_entry *me = dummy_mount_list; me; me = me->me_next) {
+			if (np_regex_match_mount_entry(me, &regex)) {
 				matches++;
+			}
 		}
 		ok(matches == expect, "%s '%s' matched %i/3 entries. ok: %i/3", desc, regstr, expect, matches);
 
-	} else
+	} else {
 		ok(false, "regex '%s' not compilable", regstr);
+	}
 }
-- 
cgit v1.2.3-74-g34f1


From 76971dea753d52d3e177aa84605d9b239a3a793e Mon Sep 17 00:00:00 2001
From: Lorenz Kästle <12514511+RincewindsHat@users.noreply.github.com>
Date: Sun, 30 Mar 2025 22:38:12 +0200
Subject: Address check_disk changes in tests

---
 plugins/t/check_disk.t          | 205 +++++++++++++++++++++++-----------------
 plugins/tests/test_check_disk.c |  67 ++++++-------
 2 files changed, 154 insertions(+), 118 deletions(-)

(limited to 'plugins/tests/test_check_disk.c')

diff --git a/plugins/t/check_disk.t b/plugins/t/check_disk.t
index 9eb77ce4..16daee9a 100644
--- a/plugins/t/check_disk.t
+++ b/plugins/t/check_disk.t
@@ -10,6 +10,7 @@ use strict;
 use Test::More;
 use NPTest;
 use POSIX qw(ceil floor);
+use Data::Dumper;
 
 my $successOutput = '/^DISK OK/';
 my $failureOutput = '/^DISK CRITICAL/';
@@ -20,117 +21,148 @@ my $result;
 my $mountpoint_valid  = getTestParameter( "NP_MOUNTPOINT_VALID", "Path to valid mountpoint",  "/");
 my $mountpoint2_valid = getTestParameter( "NP_MOUNTPOINT2_VALID", "Path to another valid mountpoint. Must be different from 1st one", "/var");
 
+my $output_format = "--output-format mp-test-json";
+
 if ($mountpoint_valid eq "" or $mountpoint2_valid eq "") {
 	plan skip_all => "Need 2 mountpoints to test";
 } else {
-	plan tests => 94;
+	plan tests => 96;
 }
 
 $result = NPTest->testCmd(
-	"./check_disk -w 1% -c 1% -p $mountpoint_valid -w 1% -c 1% -p $mountpoint2_valid"
+	"./check_disk -w 1% -c 1% -p $mountpoint_valid -w 1% -c 1% -P -p $mountpoint2_valid $output_format"
 	);
 cmp_ok( $result->return_code, "==", 0, "Checking two mountpoints (must have at least 1% free in space and inodes)");
-my $c = 0;
-$_ = $result->output;
-$c++ while /\(/g;	# counts number of "(" - should be two
-cmp_ok( $c, '==', 2, "Got two mountpoints in output");
 
+like($result->{'mp_test_result'}->{'state'}, "/OK/", "Main result is OK");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'state'}, "/OK/", "First sub result is OK");
+like($result->{'mp_test_result'}->{'checks'}->[1]->{'state'}, "/OK/", "Second sub result is OK");
+
+my $absolut_space_mp1 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+# print("absolut space on mp1: ". $absolut_space_mp1 . "\n");
+
+my $free_percent_on_mp1 = ($result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'} / ($absolut_space_mp1/100));
+print("free percent on mp1: ". $free_percent_on_mp1 . "\n");
+
+my $absolut_space_mp2 = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+# print("absolut space on mp2: ". $absolut_space_mp2 . "\n");
 
-# Get perf data
-# Should use Monitoring::Plugin
-my @perf_data = sort(split(/ /, $result->perf_output));
+my $free_percent_on_mp2 = ($result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'}/ ($absolut_space_mp2/100));
+print("free percent on mp2: ". $free_percent_on_mp2 . "\n");
 
+my @perfdata;
+@perfdata[0] = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0];
+@perfdata[1] = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0];
 
 # Calculate avg_free free on mountpoint1 and mountpoint2
 # because if you check in the middle, you should get different errors
-$_ = $result->output;
-my ($free_on_mp1, $free_on_mp2) = (m/\((\d+\.\d+)%.*\((\d+\.\d+)%/);
-die "Cannot parse output: $_" unless ($free_on_mp1 && $free_on_mp2);
-my $avg_free = ceil(($free_on_mp1+$free_on_mp2)/2);
+my $avg_free_percent = ceil(($free_percent_on_mp1+$free_percent_on_mp2)/2);
+# print("avg_free: " . $avg_free_percent . "\n");
 my ($more_free, $less_free);
-if ($free_on_mp1 > $free_on_mp2) {
+if ($free_percent_on_mp1 > $free_percent_on_mp2) {
 	$more_free = $mountpoint_valid;
 	$less_free = $mountpoint2_valid;
-} elsif ($free_on_mp1 < $free_on_mp2) {
+} elsif ($free_percent_on_mp1 < $free_percent_on_mp2) {
 	$more_free = $mountpoint2_valid;
 	$less_free = $mountpoint_valid;
 } else {
 	die "Two mountpoints are the same - cannot do rest of test";
 }
-if($free_on_mp1 == $avg_free || $free_on_mp2 == $avg_free) {
+
+print("less free: " . $less_free . "\n");
+print("more free: " . $more_free . "\n");
+
+if($free_percent_on_mp1 == $avg_free_percent || $free_percent_on_mp2 == $avg_free_percent) {
 	die "One mountpoints has average space free - cannot do rest of test";
 }
 
+my $free_inodes_on_mp1 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}[2]->{'perfdata'}->[0]->{'value'}->{'value'};
+my $total_inodes_on_mp1 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}[2]->{'perfdata'}->[0]->{'max'}->{'value'};
+my $free_inode_percentage_on_mp1 = $free_inodes_on_mp1 / ($total_inodes_on_mp1 / 100);
 
-# Do same for inodes
-$_ = $result->output;
-my ($free_inode_on_mp1, $free_inode_on_mp2) = (m/inode=(\d+)%.*inode=(\d+)%/);
-die "Cannot parse free inodes: $_" unless ($free_inode_on_mp1 && $free_inode_on_mp2);
-my $avg_inode_free = ceil(($free_inode_on_mp1 + $free_inode_on_mp2)/2);
+my $free_inodes_on_mp2 = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[2]->{'perfdata'}->[0]->{'value'}->{'value'};
+my $total_inodes_on_mp2 = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[2]->{'perfdata'}->[0]->{'max'}->{'value'};
+my $free_inode_percentage_on_mp2 = $free_inodes_on_mp2 / ($total_inodes_on_mp2 / 100);
+
+my $avg_inode_free_percentage = ceil(($free_inode_percentage_on_mp1 + $free_inode_percentage_on_mp2)/2);
 my ($more_inode_free, $less_inode_free);
-if ($free_inode_on_mp1 > $free_inode_on_mp2) {
+if ($free_inode_percentage_on_mp1 > $free_inode_percentage_on_mp2) {
 	$more_inode_free = $mountpoint_valid;
 	$less_inode_free = $mountpoint2_valid;
-} elsif ($free_inode_on_mp1 < $free_inode_on_mp2) {
+} elsif ($free_inode_percentage_on_mp1 < $free_inode_percentage_on_mp2) {
 	$more_inode_free = $mountpoint2_valid;
 	$less_inode_free = $mountpoint_valid;
 } else {
 	die "Two mountpoints with same inodes free - cannot do rest of test";
 }
-if($free_inode_on_mp1 == $avg_inode_free || $free_inode_on_mp2 == $avg_inode_free) {
+if($free_inode_percentage_on_mp1 == $avg_inode_free_percentage || $free_inode_percentage_on_mp2 == $avg_inode_free_percentage) {
 	die "One mountpoints has average inodes free - cannot do rest of test";
 }
 
 # Verify performance data
 # First check absolute thresholds...
 $result = NPTest->testCmd(
-        "./check_disk -w 20 -c 10 -p $mountpoint_valid"
+        "./check_disk -w 20 -c 10 -p $mountpoint_valid $output_format"
         );
-$_ = $result->perf_output;
-my ($warn_absth_data, $crit_absth_data, $total_absth_data) = (m/=.[^;]*;(\d+);(\d+);\d+;(\d+)/);
-# default unit is MiB, but perfdata is always bytes
-is ($warn_absth_data, $total_absth_data - (20 * (2 ** 20)), "Wrong warning in perf data using absolute thresholds");
-is ($crit_absth_data, $total_absth_data - (10 * (2 ** 20)), "Wrong critical in perf data using absolute thresholds");
+
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+
+my $warn_absth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'warn'}->{'end'}->{'value'};
+my $crit_absth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'crit'}->{'end'}->{'value'};
+my $total_absth_data= $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+
+# print("warn: " .$warn_absth_data . "\n");
+# print("crit: " .$crit_absth_data . "\n");
+# print("total: " .$total_absth_data . "\n");
+
+is ($warn_absth_data <=>  (20 * (2 ** 20)), 0, "Wrong warning in perf data using absolute thresholds");
+is ($crit_absth_data <=>  (10 * (2 ** 20)), 0, "Wrong critical in perf data using absolute thresholds");
 
 # Then check percent thresholds.
 $result = NPTest->testCmd(
-        "./check_disk -w 20% -c 10% -p $mountpoint_valid"
+        "./check_disk -w 20% -c 10% -p $mountpoint_valid $output_format"
         );
-$_ = $result->perf_output;
-my ($warn_percth_data, $crit_percth_data, $total_percth_data) = (m/=.[^;]*;(\d+);(\d+);\d+;(\d+)/);
-is ($warn_percth_data, int((1-20/100)*$total_percth_data), "Wrong warning in perf data using percent thresholds");
-is ($crit_percth_data, int((1-10/100)*$total_percth_data), "Wrong critical in perf data using percent thresholds");
+
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+
+my $warn_percth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'warn'}->{'end'}->{'value'};
+my $crit_percth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'crit'}->{'end'}->{'value'};
+my $total_percth_data = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}[0]->{'perfdata'}->[0]->{'max'}->{'value'};
+
+is ($warn_percth_data <=> int((20/100)*$total_percth_data), 0, "Wrong warning in perf data using percent thresholds");
+is ($crit_percth_data <=> int((10/100)*$total_percth_data), 0, "Wrong critical in perf data using percent thresholds");
 
 
 # Check when order of mount points are reversed, that perf data remains same
 $result = NPTest->testCmd(
-	"./check_disk -w 1% -c 1% -p $mountpoint2_valid -w 1% -c 1% -p $mountpoint_valid"
+	"./check_disk -w 1% -c 1% -p $mountpoint2_valid -w 1% -c 1% -p $mountpoint_valid $output_format"
 	);
-@_ = sort(split(/ /, $result->perf_output));
-is_deeply( \@perf_data, \@_, "perf data for both filesystems same when reversed");
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
 
+# write comparison set for perfdata here, but in reversed order, maybe there is a smarter way
+my @perfdata2;
+@perfdata2[1] = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0];
+@perfdata2[0] = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0];
+is_deeply(\@perfdata, \@perfdata2, "perf data for both filesystems same when reversed");
 
 # Basic filesystem checks for sizes
-$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free" );
-cmp_ok( $result->return_code, '==', 0, "At least 1 MB available on $more_free");
-like  ( $result->output, $successOutput, "OK output" );
-like  ( $result->only_output, qr/free space/, "Have free space text");
-like  ( $result->only_output, qr/$more_free/, "Have disk name in text");
+$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free $output_format");
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/OK/", "At least 1 MB available on $more_free");
 
-$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free -p $less_free" );
-cmp_ok( $result->return_code, '==', 0, "At least 1 MB available on $more_free and $less_free");
+$result = NPTest->testCmd( "./check_disk -w 1 -c 1 -p $more_free -p $less_free $output_format" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/OK/", "At least 1 MB available on $more_free and $less_free");
 
-$_ = $result->output;
-
-my ($free_mb_on_mp1, $free_mb_on_mp2) = (m/(\d+)MiB .* (\d+)MiB /g);
+my $free_mb_on_mp1 =$result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'} / (1024 * 1024);
+my $free_mb_on_mp2 = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0]->{'value'}->{'value'}/ (1024 * 1024);
 die "Cannot parse output: $_" unless ($free_mb_on_mp1 && $free_mb_on_mp2);
 
 my $free_mb_on_all = $free_mb_on_mp1 + $free_mb_on_mp2;
 
 
-
-$result = NPTest->testCmd( "./check_disk -e -w 1 -c 1 -p $more_free" );
-is( $result->only_output, "DISK OK", "No print out of disks with -e for OKs");
+$result = NPTest->testCmd( "./check_disk -e -w 1 -c 1 -p $more_free $output_format" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
 
 $result = NPTest->testCmd( "./check_disk 100 100 $more_free" );
 cmp_ok( $result->return_code, '==', 0, "Old syntax okay" );
@@ -139,54 +171,55 @@ $result = NPTest->testCmd( "./check_disk -w 1% -c 1% -p $more_free" );
 cmp_ok( $result->return_code, "==", 0, "At least 1% free" );
 
 $result = NPTest->testCmd(
-	"./check_disk -w 1% -c 1% -p $more_free -w 100% -c 100% -p $less_free"
+	"./check_disk -w 1% -c 1% -p $more_free -w 100% -c 100% -p $less_free $output_format"
 	);
-cmp_ok( $result->return_code, "==", 2, "Get critical on less_free mountpoint $less_free" );
-like( $result->output, $failureOutput, "Right output" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/CRITICAL/", "Get critical on less_free mountpoint $less_free");
 
 
 $result = NPTest->testCmd(
-	"./check_disk -w $avg_free% -c 0% -p $less_free"
+	"./check_disk -w $avg_free_percent% -c 0% -p $less_free $output_format"
 	);
-cmp_ok( $result->return_code, '==', 1, "Get warning on less_free mountpoint, when checking avg_free");
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+like($result->{'mp_test_result'}->{'state'}, "/WARNING/", "Get warning on less_free mountpoint, when checking avg_free");
 
 $result = NPTest->testCmd(
-	"./check_disk -w $avg_free% -c $avg_free% -p $more_free"
+	"./check_disk -w $avg_free_percent% -c $avg_free_percent% -p $more_free"
 	);
 cmp_ok( $result->return_code, '==', 0, "Get ok on more_free mountpoint, when checking avg_free");
 
 $result = NPTest->testCmd(
-	"./check_disk -w $avg_free% -c 0% -p $less_free -w $avg_free% -c $avg_free% -p $more_free"
+	"./check_disk -w $avg_free_percent% -c 0% -p $less_free -w $avg_free_percent% -c $avg_free_percent% -p $more_free"
 	);
 cmp_ok( $result->return_code, "==", 1, "Combining above two tests, get warning");
 my $all_disks = $result->output;
 
 $result = NPTest->testCmd(
-	"./check_disk -e -w $avg_free% -c 0% -p $less_free -w $avg_free% -c $avg_free% -p $more_free"
+	"./check_disk -e -w $avg_free_percent% -c 0% -p $less_free -w $avg_free_percent% -c $avg_free_percent% -p $more_free"
 	);
 isnt( $result->output, $all_disks, "-e gives different output");
 
 # Need spaces around filesystem name in case less_free and more_free are nested
 like( $result->output, qr/ $less_free /, "Found problem $less_free");
 unlike( $result->only_output, qr/ $more_free /, "Has ignored $more_free as not a problem");
-like( $result->perf_output, qr/ $more_free=/, "But $more_free is still in perf data");
+like( $result->perf_output, qr/'$more_free'=/, "But $more_free is still in perf data");
 
 $result = NPTest->testCmd(
-	"./check_disk -w $avg_free% -c 0% -p $more_free"
+	"./check_disk -w $avg_free_percent% -c 0% -p $more_free"
 	);
 cmp_ok( $result->return_code, '==', 0, "Get ok on more_free mountpoint, checking avg_free");
 
 $result = NPTest->testCmd(
-	"./check_disk -w $avg_free% -c $avg_free% -p $less_free"
+	"./check_disk -w $avg_free_percent% -c $avg_free_percent% -p $less_free"
 	);
 cmp_ok( $result->return_code, '==', 2, "Get critical on less_free, checking avg_free");
 $result = NPTest->testCmd(
-	"./check_disk -w $avg_free% -c 0% -p $more_free -w $avg_free% -c $avg_free% -p $less_free"
+	"./check_disk -w $avg_free_percent% -c 0% -p $more_free -w $avg_free_percent% -c $avg_free_percent% -p $less_free"
 	);
 cmp_ok( $result->return_code, '==', 2, "Combining above two tests, get critical");
 
 $result = NPTest->testCmd(
-	"./check_disk -w $avg_free% -c $avg_free% -p $less_free -w $avg_free% -c 0% -p $more_free"
+	"./check_disk -w $avg_free_percent% -c $avg_free_percent% -p $less_free -w $avg_free_percent% -c 0% -p $more_free"
 	);
 cmp_ok( $result->return_code, '==', 2, "And reversing arguments should not make a difference");
 
@@ -203,32 +236,32 @@ is( $result->return_code, 2, "Critical requesting 100% free inodes for both moun
 $result = NPTest->testCmd( "./check_disk --iwarning 1% --icritical 1% -p $more_inode_free -K 100% -W 100% -p $less_inode_free" );
 is( $result->return_code, 2, "Get critical on less_inode_free mountpoint $less_inode_free");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $less_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $less_inode_free" );
 is( $result->return_code, 1, "Get warning on less_inode_free, when checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K $avg_inode_free% -p $more_inode_free ");
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $more_inode_free ");
 is( $result->return_code, 0, "Get ok on more_inode_free when checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $less_inode_free -W $avg_inode_free% -K $avg_inode_free% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $less_inode_free -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $more_inode_free" );
 is ($result->return_code, 1, "Combine above two tests, get warning");
 $all_disks = $result->output;
 
-$result = NPTest->testCmd( "./check_disk -e -W $avg_inode_free% -K 0% -p $less_inode_free -W $avg_inode_free% -K $avg_inode_free% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -e -W $avg_inode_free_percentage% -K 0% -p $less_inode_free -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $more_inode_free" );
 isnt( $result->output, $all_disks, "-e gives different output");
 like( $result->output, qr/$less_inode_free/, "Found problem $less_inode_free");
 unlike( $result->only_output, qr/$more_inode_free\s/, "Has ignored $more_inode_free as not a problem");
 like( $result->perf_output, qr/$more_inode_free/, "But $more_inode_free is still in perf data");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $more_inode_free" );
 is( $result->return_code, 0, "Get ok on more_inode_free mountpoint, checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K $avg_inode_free% -p $less_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $less_inode_free" );
 is( $result->return_code, 2, "Get critical on less_inode_free, checking average");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K 0% -p $more_inode_free -W $avg_inode_free% -K $avg_inode_free% -p $less_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K 0% -p $more_inode_free -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $less_inode_free" );
 is( $result->return_code, 2, "Combining above two tests, get critical");
 
-$result = NPTest->testCmd( "./check_disk -W $avg_inode_free% -K $avg_inode_free% -p $less_inode_free -W $avg_inode_free% -K 0% -p $more_inode_free" );
+$result = NPTest->testCmd( "./check_disk -W $avg_inode_free_percentage% -K $avg_inode_free_percentage% -p $less_inode_free -W $avg_inode_free_percentage% -K 0% -p $more_inode_free" );
 cmp_ok( $result->return_code, '==', 2, "And reversing arguments should not make a difference");
 
 
@@ -249,9 +282,9 @@ $result = NPTest->testCmd(
 	);
 cmp_ok( $result->return_code, "==", 3, "Invalid options: -p must come after thresholds" );
 
-$result = NPTest->testCmd( "./check_disk -w 100% -c 100% ".${mountpoint_valid} );      # 100% empty
-cmp_ok( $result->return_code, "==", 2, "100% empty" );
-like( $result->output, $failureOutput, "Right output" );
+$result = NPTest->testCmd( "./check_disk -w 100% -c 100% $output_format ".${mountpoint_valid} );      # 100% empty
+cmp_ok( $result->return_code, "==", 0, "100% empty" );
+like($result->{'mp_test_result'}->{'state'}, "/CRITICAL/", "100% empty");
 
 $result = NPTest->testCmd( "./check_disk -w 100000000 -c 100000000 $mountpoint_valid" );
 cmp_ok( $result->return_code, '==', 2, "Check for 100TB free" );
@@ -263,7 +296,8 @@ cmp_ok( $result->return_code, "==", 2, "100 TB empty" );
 # Checking old syntax of check_disk warn crit [fs], with warn/crit at USED% thresholds
 $result = NPTest->testCmd( "./check_disk 0 0 ".${mountpoint_valid} );
 cmp_ok( $result->return_code, "==", 2, "Old syntax: 0% used");
-like ( $result->only_output, qr(^[^;]*;[^;]*$), "Select only one path with positional arguments");
+# like ( $result->only_output, qr(^[^;]*;[^;]*$), "Select only one path with positional arguments");
+# TODO not sure what the above should test, taking it out
 
 $result = NPTest->testCmd( "./check_disk 100 100 $mountpoint_valid" );
 cmp_ok( $result->return_code, '==', 0, "Old syntax: 100% used" );
@@ -311,8 +345,9 @@ $result = NPTest->testCmd( "./check_disk -w 0% -c 0% -p / -p /" );
 unlike( $result->output, '/ \/ .* \/ /', "Should not show same filesystem twice");
 
 # are partitions added if -C is given without path selection -p ?
-$result = NPTest->testCmd( "./check_disk -w 0% -c 0% -C -w 0% -c 0% -p $mountpoint_valid" );
-like( $result->output, '/;.*;\|/', "-C selects partitions if -p is not given");
+$result = NPTest->testCmd( "./check_disk -w 0% -c 0% -C -w 0% -c 0% -p $mountpoint_valid $output_format" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
+cmp_ok(scalar $result->{'mp_test_result'}->{'checks'}, '>', 1, "-C invokes matchall logic again");
 
 # grouping: exit crit if the sum of free megs on mp1+mp2 is less than warn/crit
 $result = NPTest->testCmd( "./check_disk -w ". ($free_mb_on_all + 1) ." -c ". ($free_mb_on_all + 1) ." -g group -p $mountpoint_valid -p $mountpoint2_valid" );
@@ -359,39 +394,37 @@ like( $result->output, qr/$mountpoint2_valid/,"ignore: output data does have $mo
 # ignore-missing: exit okay, when fs is not accessible
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -p /bob");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for not existing filesystem /bob");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters - ignored paths: /bob;.*$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when regex does not match
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -r /bob");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters.*$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when fs with exact match (-E) is not found
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -E -p /etc");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay when exact match does not find fs");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters - ignored paths: /etc;.*$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when checking one existing fs and one non-existing fs (regex)
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -r '/bob' -r '^/\$'");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - free space: \/ .*$/', 'Output OK');
 
 # ignore-missing: exit okay, when checking one existing fs and one non-existing fs (path)
 $result = NPTest->testCmd( "./check_disk --ignore-missing -w 0% -c 0% -p '/bob' -p '/'");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - free space: / .*; - ignored paths: /bob;.*$/', 'Output OK');
+# like( $result->output, '/^DISK OK - free space: / .*; - ignored paths: /bob;.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when checking one non-existing fs (path) and one ignored
 $result = NPTest->testCmd( "./check_disk -n -w 0% -c 0% -r /dummy -i /dummy2");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters\|$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
 
 # ignore-missing: exit okay, when regex match does not find anything
 $result = NPTest->testCmd( "./check_disk -n -e -l -w 10% -c 5% -W 10% -K 5% -r /dummy");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK\|$/', 'Output OK');
 
 # ignore-missing: exit okay, when regex match does not find anything
 $result = NPTest->testCmd( "./check_disk -n -l -w 10% -c 5% -W 10% -K 5% -r /dummy");
 cmp_ok( $result->return_code, '==', 0, "ignore-missing: return okay for regular expression not matching");
-like( $result->output, '/^DISK OK - No disks were found for provided parameters\|$/', 'Output OK');
+like( $result->output, '/No filesystems were found for the provided parameters.*$/', 'Output OK');
diff --git a/plugins/tests/test_check_disk.c b/plugins/tests/test_check_disk.c
index 963a9413..35c57bce 100644
--- a/plugins/tests/test_check_disk.c
+++ b/plugins/tests/test_check_disk.c
@@ -24,7 +24,7 @@
 void np_test_mount_entry_regex(struct mount_entry *dummy_mount_list, char *regstr, int cflags, int expect, char *desc);
 
 int main(int argc, char **argv) {
-	plan_tests(33);
+	plan_tests(35);
 
 	struct name_list *exclude_filesystem = NULL;
 	ok(np_find_name(exclude_filesystem, "/var/log") == false, "/var/log not in list");
@@ -81,15 +81,16 @@ int main(int argc, char **argv) {
 	np_test_mount_entry_regex(dummy_mount_list, strdup("(/home)|(/var)"), cflags, 2, strdup("grouped regex pathname match:"));
 	np_test_mount_entry_regex(dummy_mount_list, strdup("(/homE)|(/Var)"), cflags | REG_ICASE, 2, strdup("grouped regi pathname match:"));
 
-	struct parameter_list *paths = NULL;
-	np_add_parameter(&paths, "/home/groups");
-	np_add_parameter(&paths, "/var");
-	np_add_parameter(&paths, "/tmp");
-	np_add_parameter(&paths, "/home/tonvoon");
-	np_add_parameter(&paths, "/dev/c2t0d0s0");
+	filesystem_list test_paths = filesystem_list_init();
+	mp_int_fs_list_append(&test_paths, "/home/groups");
+	mp_int_fs_list_append(&test_paths, "/var");
+	mp_int_fs_list_append(&test_paths, "/tmp");
+	mp_int_fs_list_append(&test_paths, "/home/tonvoon");
+	mp_int_fs_list_append(&test_paths, "/dev/c2t0d0s0");
+	ok(test_paths.length == 5, "List counter works correctly with appends");
 
-	np_set_best_match(paths, dummy_mount_list, false);
-	for (struct parameter_list *p = paths; p; p = p->name_next) {
+	mp_int_fs_list_set_best_match(test_paths, dummy_mount_list, false);
+	for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
 		struct mount_entry *temp_me;
 		temp_me = p->best_match;
 		if (!strcmp(p->name, "/home/groups")) {
@@ -105,15 +106,19 @@ int main(int argc, char **argv) {
 		}
 	}
 
-	paths = NULL; /* Bad boy - should free, but this is a test suite */
-	np_add_parameter(&paths, "/home/groups");
-	np_add_parameter(&paths, "/var");
-	np_add_parameter(&paths, "/tmp");
-	np_add_parameter(&paths, "/home/tonvoon");
-	np_add_parameter(&paths, "/home");
+	for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
+		mp_int_fs_list_del(&test_paths, p);
+	}
+	ok(test_paths.length == 0, "List delete sets counter properly");
+
+	mp_int_fs_list_append(&test_paths, "/home/groups");
+	mp_int_fs_list_append(&test_paths, "/var");
+	mp_int_fs_list_append(&test_paths, "/tmp");
+	mp_int_fs_list_append(&test_paths, "/home/tonvoon");
+	mp_int_fs_list_append(&test_paths, "/home");
 
-	np_set_best_match(paths, dummy_mount_list, true);
-	for (struct parameter_list *p = paths; p; p = p->name_next) {
+	mp_int_fs_list_set_best_match(test_paths, dummy_mount_list, true);
+	for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
 		if (!strcmp(p->name, "/home/groups")) {
 			ok(!p->best_match, "/home/groups correctly not found");
 		} else if (!strcmp(p->name, "/var")) {
@@ -129,8 +134,8 @@ int main(int argc, char **argv) {
 
 	bool found = false;
 	/* test deleting first element in paths */
-	paths = np_del_parameter(paths, NULL);
-	for (struct parameter_list *p = paths; p; p = p->name_next) {
+	mp_int_fs_list_del(&test_paths, NULL);
+	for (parameter_list_elem *p = test_paths.first; p; p = mp_int_fs_list_get_next(p)) {
 		if (!strcmp(p->name, "/home/groups")) {
 			found = true;
 		}
@@ -138,23 +143,21 @@ int main(int argc, char **argv) {
 	ok(!found, "first element successfully deleted");
 	found = false;
 
-	struct parameter_list *prev = NULL;
-	struct parameter_list *p = paths;
-	while (p) {
-		if (!strcmp(p->name, "/tmp")) {
-			p = np_del_parameter(p, prev);
-		} else {
-			prev = p;
-			p = p->name_next;
+	parameter_list_elem *prev = NULL;
+	parameter_list_elem *p = NULL;
+	for (parameter_list_elem *path = test_paths.first; path; path = mp_int_fs_list_get_next(path)) {
+		if (!strcmp(path->name, "/tmp")) {
+			mp_int_fs_list_del(&test_paths, path);
 		}
+		p = path;
 	}
 
-	struct parameter_list *last = NULL;
-	for (struct parameter_list *path = paths; path; path = path->name_next) {
+	parameter_list_elem *last = NULL;
+	for (parameter_list_elem *path = test_paths.first; path; path = mp_int_fs_list_get_next(path)) {
 		if (!strcmp(path->name, "/tmp")) {
 			found = true;
 		}
-		if (path->name_next) {
+		if (path->next) {
 			prev = path;
 		} else {
 			last = path;
@@ -163,8 +166,8 @@ int main(int argc, char **argv) {
 	ok(!found, "/tmp element successfully deleted");
 
 	int count = 0;
-	p = np_del_parameter(last, prev);
-	for (p = paths; p; p = p->name_next) {
+	mp_int_fs_list_del(&test_paths, p);
+	for (p = test_paths.first; p; p = p->next) {
 		if (!strcmp(p->name, "/home")) {
 			found = true;
 		}
-- 
cgit v1.2.3-74-g34f1