12 files changed, 280 insertions, 177 deletions

diff --git a/plugins/t/check_disk.t b/plugins/t/check_disk.t
index 9eb77ce4..0f62fb2b 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,173 +21,216 @@ 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 => 97;
 }
 
 $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("absolute 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("absolute space on mp2: ". $absolut_space_mp2 . "\n");
+
+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");
 
-# Get perf data
-# Should use Monitoring::Plugin
-my @perf_data = sort(split(/ /, $result->perf_output));
+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];
 
+# Decrease precision of numbers since the the fs might be modified between the two runs
+$perfdata[0]->{'value'}->{'value'} = int($perfdata[0]->{'value'}->{'value'} / 1000000);
+$perfdata[1]->{'value'}->{'value'} = int($perfdata[1]->{'value'}->{'value'} / 1000000);
 
 # 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'};
+
+print("warn_percth_data: " . $warn_percth_data . "\n");
+print("crit_percth_data: " . $crit_percth_data . "\n");
+
+is (int($warn_percth_data), int((20/100)*$total_percth_data), "Wrong warning in perf data using percent thresholds. Got " . $warn_percth_data . " with total " . $total_percth_data);
+is (int($crit_percth_data), int((10/100)*$total_percth_data), "Wrong critical in perf data using percent thresholds. Got " . $crit_percth_data . " with total " . $total_percth_data);
 
 
 # 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[0] = $result->{'mp_test_result'}->{'checks'}->[1]->{'checks'}->[0]->{'perfdata'}->[0];
+@perfdata2[1] = $result->{'mp_test_result'}->{'checks'}->[0]->{'checks'}->[0]->{'perfdata'}->[0];
+# Decrease precision of numbers since the the fs might be modified between the two runs
+$perfdata2[0]->{'value'}->{'value'} = int($perfdata2[0]->{'value'}->{'value'} / 1000000);
+$perfdata2[1]->{'value'}->{'value'} = int($perfdata2[1]->{'value'}->{'value'} / 1000000);
+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 $output_format" );
+cmp_ok( $result->return_code, "==", 0, "with JSON test format result should always be OK");
 
-$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 100 100 $more_free" );
-cmp_ok( $result->return_code, '==', 0, "Old syntax okay" );
+$result = NPTest->testCmd( "./check_disk 101 101 $more_free" );
+like($result->output, "/OK/", "OK in Output");
+cmp_ok( $result->return_code, '==', 0, "Old syntax okay, output was: ". $result->output . "\n" );
 
 $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 +247,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 +293,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 +307,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 +356,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 +405,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/t/check_ftp.t b/plugins/t/check_ftp.t
index 93a7d7c3..a2f79dca 100644
--- a/plugins/t/check_ftp.t
+++ b/plugins/t/check_ftp.t
@@ -15,7 +15,7 @@ my $host_tcp_ftp       = getTestParameter("NP_HOST_TCP_FTP", "A host providing t
 my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname of system not responsive to network requests", "10.0.0.1");
 my $hostname_invalid   = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
 
-my $successOutput = '/FTP OK -\s+[0-9]?\.?[0-9]+ second response time/';
+my $successOutput = '/Connection time\s+[0-9]?\.?[0-9]+/';
 
 my $t;
 
diff --git a/plugins/t/check_http.t b/plugins/t/check_http.t
index 6ab4a5b6..bb1fd27d 100644
--- a/plugins/t/check_http.t
+++ b/plugins/t/check_http.t
@@ -45,7 +45,7 @@ $res = NPTest->testCmd(
         "./$plugin $host_nonresponsive -wt 1 -ct 2 -t 3"
         );
 cmp_ok( $res->return_code, '==', 2, "Webserver $host_nonresponsive not responding" );
-cmp_ok( $res->output, 'eq', "CRITICAL - Socket timeout after 3 seconds", "Output OK");
+like( $res->output, "/Socket timeout after/", "Output OK");
 
 $res = NPTest->testCmd(
         "./$plugin $hostname_invalid -wt 1 -ct 2"
diff --git a/plugins/t/check_jabber.t b/plugins/t/check_jabber.t
index fcdae179..dc46f4c3 100644
--- a/plugins/t/check_jabber.t
+++ b/plugins/t/check_jabber.t
@@ -15,11 +15,11 @@ my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname
 my $hostname_invalid   = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
 
 
-my $jabberOK = '/JABBER OK\s-\s\d+\.\d+\ssecond response time on '.$host_tcp_jabber.' port 5222/';
+my $jabberOK = '/Connection to '.$host_tcp_jabber.' on port 5222/';
 
-my $jabberUnresponsive = '/CRITICAL\s-\sSocket timeout after\s\d+\sseconds/';
+my $jabberUnresponsive = '/Socket timeout after\s\d+\sseconds/';
 
-my $jabberInvalid = '/JABBER CRITICAL - Invalid hostname, address or socket:\s.+/';
+my $jabberInvalid = '/Invalid hostname, address or socket:\s.+/';
 
 my $r;
 
diff --git a/plugins/t/check_ldap.t b/plugins/t/check_ldap.t
index b8a4a766..fcba0393 100644
--- a/plugins/t/check_ldap.t
+++ b/plugins/t/check_ldap.t
@@ -24,7 +24,7 @@ SKIP: {
 
     $result = NPTest->testCmd("$command -H $host_nonresponsive -b ou=blah -t 2 -w 1 -c 1");
     is( $result->return_code, 2, "$command -H $host_nonresponsive -b ou=blah -t 5 -w 2 -c 3" );
-    is( $result->output, 'CRITICAL - Socket timeout after 2 seconds', "output ok" );
+    like($result->output, '/Socket timeout after \d+ seconds/', "output ok" );
 };
 
 SKIP: {
diff --git a/plugins/t/check_mysql.t b/plugins/t/check_mysql.t
index baf3acc6..a383bc99 100644
--- a/plugins/t/check_mysql.t
+++ b/plugins/t/check_mysql.t
@@ -21,11 +21,11 @@ plan skip_all => "check_mysql not compiled" unless (-x "check_mysql");
 plan tests => 15;
 
 my $bad_login_output = '/Access denied for user /';
-my $mysqlserver         = getTestParameter("NP_MYSQL_SERVER", "A MySQL Server hostname or IP with no slaves setup");
-my $mysqlsocket         = getTestParameter("NP_MYSQL_SOCKET", "Full path to a MySQL Server socket with no slaves setup");
+my $mysqlserver         = getTestParameter("NP_MYSQL_SERVER", "A MySQL Server hostname or IP with no replica setup");
+my $mysqlsocket         = getTestParameter("NP_MYSQL_SOCKET", "Full path to a MySQL Server socket with no replica setup");
 my $mysql_login_details = getTestParameter("NP_MYSQL_LOGIN_DETAILS", "Command line parameters to specify login access (requires REPLICATION CLIENT privileges)", "-u test -ptest");
-my $with_slave          = getTestParameter("NP_MYSQL_WITH_SLAVE", "MySQL server with slaves setup");
-my $with_slave_login    = getTestParameter("NP_MYSQL_WITH_SLAVE_LOGIN", "Login details for server with slave (requires REPLICATION CLIENT privileges)", $mysql_login_details || "-u test -ptest");
+my $with_replica          = getTestParameter("NP_MYSQL_WITH_REPLICA", "MySQL server with replica setup");
+my $with_replica_login    = getTestParameter("NP_MYSQL_WITH_REPLICA_LOGIN", "Login details for server with replica (requires REPLICATION CLIENT privileges)", $mysql_login_details || "-u test -ptest");
 
 my $result;
 
@@ -39,8 +39,8 @@ SKIP: {
         like( $result->output, $bad_login_output, "Expected login failure message");
 
         $result = NPTest->testCmd("./check_mysql -S -H $mysqlserver $mysql_login_details");
-        cmp_ok( $result->return_code, "==", 1, "No slaves defined" );
-        like( $result->output, "/No slaves defined/", "Correct error message");
+        cmp_ok( $result->return_code, "==", 1, "No replicas defined" );
+        like( $result->output, "/No replicas defined/", "Correct error message");
 }
 
 SKIP: {
@@ -53,22 +53,22 @@ SKIP: {
         like( $result->output, $bad_login_output, "Expected login failure message");
 
         $result = NPTest->testCmd("./check_mysql -S -s $mysqlsocket $mysql_login_details");
-        cmp_ok( $result->return_code, "==", 1, "No slaves defined" );
-        like( $result->output, "/No slaves defined/", "Correct error message");
+        cmp_ok( $result->return_code, "==", 1, "No replicas defined" );
+        like( $result->output, "/No replicas defined/", "Correct error message");
 }
 
 SKIP: {
-        skip "No mysql server with slaves defined", 5 unless $with_slave;
-        $result = NPTest->testCmd("./check_mysql -H $with_slave $with_slave_login");
+        skip "No mysql server with replicas defined", 5 unless $with_replica;
+        $result = NPTest->testCmd("./check_mysql -H $with_replica $with_replica_login");
         cmp_ok( $result->return_code, '==', 0, "Login okay");
 
-        $result = NPTest->testCmd("./check_mysql -S -H $with_slave $with_slave_login");
-        cmp_ok( $result->return_code, "==", 0, "Slaves okay" );
+        $result = NPTest->testCmd("./check_mysql -S -H $with_replica $with_replica_login");
+        cmp_ok( $result->return_code, "==", 0, "Replicas okay" );
 
-        $result = NPTest->testCmd("./check_mysql -S -H $with_slave $with_slave_login -w 60");
-        cmp_ok( $result->return_code, '==', 0, 'Slaves are not > 60 seconds behind');
+        $result = NPTest->testCmd("./check_mysql -S -H $with_replica $with_replica_login -w 60");
+        cmp_ok( $result->return_code, '==', 0, 'Replicas are not > 60 seconds behind');
 
-        $result = NPTest->testCmd("./check_mysql -S -H $with_slave $with_slave_login -w 60:");
+        $result = NPTest->testCmd("./check_mysql -S -H $with_replica $with_replica_login -w 60:");
         cmp_ok( $result->return_code, '==', 1, 'Alert warning if < 60 seconds behind');
-        like( $result->output, "/^SLOW_SLAVE WARNING:/", "Output okay");
+        like( $result->output, "/^SLOW_REPLICA WARNING:/", "Output okay");
 }
diff --git a/plugins/t/check_ntp.t b/plugins/t/check_ntp.t
index b8fc8fdf..a8ac7bb8 100644
--- a/plugins/t/check_ntp.t
+++ b/plugins/t/check_ntp.t
@@ -37,7 +37,7 @@ my $ntp_critmatch1 = '/^NTP\sCRITICAL:\sOffset\s-?[0-9]+(\.[0-9]+)?(e-[0-9]{2})?
 my $ntp_okmatch2 = '/^NTP\sOK:\sOffset\s-?[0-9]+(\.[0-9]+)?(e-[0-9]{2})?\ssecs,\sjitter=[0-9]+\.[0-9]+,\sstratum=[0-9]{1,2},\struechimers=[0-9]+/';
 my $ntp_warnmatch2 = '/^NTP\sWARNING:\sOffset\s-?[0-9]+(\.[0-9]+)?(e-[0-9]{2})?\ssecs,\sjitter=[0-9]+\.[0-9]+,\sstratum=[0-9]{1,2}\s\(WARNING\),\struechimers=[0-9]+/';
 my $ntp_critmatch2 = '/^NTP\sCRITICAL:\sOffset\s-?[0-9]+(\.[0-9]+)?(e-[0-9]{2})?\ssecs,\sjitter=[0-9]+\.[0-9]+\s\(CRITICAL\),\sstratum=[0-9]{1,2},\struechimers=[0-9]+/';
-my $ntp_noresponse = '/^(CRITICAL - Socket timeout after 3 seconds)|(NTP CRITICAL: No response from NTP server)$/';
+my $ntp_noresponse = '/(.*Socket timeout after \d+ seconds.*)|(.*No response from NTP server.*)/';
 my $ntp_nosuchhost = '/^check_ntp.*: Invalid hostname/address - ' . $hostname_invalid . '/';
 
 
diff --git a/plugins/t/check_smtp.t b/plugins/t/check_smtp.t
index 1a1ebe3e..73b4a1fd 100644
--- a/plugins/t/check_smtp.t
+++ b/plugins/t/check_smtp.t
@@ -24,7 +24,7 @@ my $hostname_invalid   = getTestParameter( "NP_HOSTNAME_INVALID",
                                            "An invalid (not known to DNS) hostname", "nosuchhost" );
 my $res;
 
-plan tests => 16;
+plan tests => 15;
 
 SKIP: {
         skip "No SMTP server defined", 4 unless $host_tcp_smtp;
@@ -73,7 +73,6 @@ SKIP: {
         my $unused_port = 4465;
         $res = NPTest->testCmd( "./check_smtp -H $host_tcp_smtp_tls -p $unused_port --ssl" );
         is ($res->return_code, 2, "Check rc of connecting to $host_tcp_smtp_tls with TLS on unused port $unused_port" );
-        like ($res->output, qr/^connect to address $host_tcp_smtp_tls and port $unused_port: Connection refused/, "Check output of connecting to $host_tcp_smtp_tls with TLS on unused port $unused_port");
 }
 
 $res = NPTest->testCmd( "./check_smtp $host_nonresponsive" );
diff --git a/plugins/t/check_ssh.t b/plugins/t/check_ssh.t
index 907d33a8..8a20782e 100644
--- a/plugins/t/check_ssh.t
+++ b/plugins/t/check_ssh.t
@@ -5,10 +5,10 @@
 #
 
 use strict;
+use warnings;
 use Test::More;
 use NPTest;
-
-my $res;
+use JSON;
 
 # Required parameters
 my $ssh_host           = getTestParameter("NP_SSH_HOST",
@@ -23,30 +23,38 @@ my $hostname_invalid   = getTestParameter("NP_HOSTNAME_INVALID",
                                           "An invalid (not known to DNS) hostname",
                                           "nosuchhost" );
 
+        my $outputFormat = '--output-format mp-test-json';
+
+plan tests => 24;
 
-plan tests => 14 + 6;
+my $output;
+my $result;
 
 SKIP: {
         skip "SSH_HOST must be defined", 6 unless $ssh_host;
+
+
         my $result = NPTest->testCmd(
-                "./check_ssh -H $ssh_host"
+                "./check_ssh -H $ssh_host" ." ". $outputFormat
                 );
         cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
-        like($result->output, '/^SSH OK - /', "Status text if command returned none (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "OK", "State was correct");
 
 
         $result = NPTest->testCmd(
-                "./check_ssh -H $host_nonresponsive -t 2"
+                "./check_ssh -H $host_nonresponsive -t 2" ." ". $outputFormat
                 );
-        cmp_ok($result->return_code, '==', 2, "Exit with return code 0 (OK)");
-        like($result->output, '/^CRITICAL - Socket timeout after 2 seconds/', "Status text if command returned none (OK)");
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "CRITICAL", "State was correct");
 
 
 
         $result = NPTest->testCmd(
-                "./check_ssh -H $hostname_invalid -t 2"
+                "./check_ssh -H $hostname_invalid -t 2" ." ". $outputFormat
                 );
-        cmp_ok($result->return_code, '==', 3, "Exit with return code 0 (OK)");
+        cmp_ok($result->return_code, '==', 3, "Exit with return code 3 (UNKNOWN)");
         like($result->output, '/^check_ssh: Invalid hostname/', "Status text if command returned none (OK)");
 
 
@@ -63,46 +71,80 @@ SKIP: {
         #
         # where `comments` is optional, protoversion is the SSH protocol version and
         # softwareversion is an arbitrary string representing the server software version
+
+        my $found_version = 0;
+
         open(NC, "echo 'SSH-2.0-nagiosplug.ssh.0.1' | nc ${nc_flags}|");
         sleep 0.1;
-        $res = NPTest->testCmd( "./check_ssh -H localhost -p 5003" );
-        cmp_ok( $res->return_code, '==', 0, "Got SSH protocol version control string");
-        like( $res->output, '/^SSH OK - nagiosplug.ssh.0.1 \(protocol 2.0\)/', "Output OK");
+        $result = NPTest->testCmd( "./check_ssh -H localhost -p 5003" ." ". $outputFormat);
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "OK", "State was correct");
+
+        # looking for the version
+        for my $subcheck (@{$output->{'checks'}}) {
+                if ($subcheck->{'output'} =~ /.*nagiosplug.ssh.0.1 \(protocol version: 2.0\).*/ ){
+                        $found_version = 1;
+                }
+        }
+        cmp_ok($found_version, '==', 1, "Output OK");
         close NC;
 
         open(NC, "echo 'SSH-2.0-3.2.9.1' | nc ${nc_flags}|");
         sleep 0.1;
-        $res = NPTest->testCmd( "./check_ssh -H localhost -p 5003" );
-        cmp_ok( $res->return_code, "==", 0, "Got SSH protocol version control string with non-alpha softwareversion string");
-        like( $res->output, '/^SSH OK - 3.2.9.1 \(protocol 2.0\)/', "Output OK for non-alpha softwareversion string");
+        $result = NPTest->testCmd( "./check_ssh -H localhost -p 5003" ." ". $outputFormat);
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "OK", "State was correct");
+
+        $found_version = 0;
+        for my $subcheck (@{$output->{'checks'}}) {
+                if ($subcheck->{'output'} =~ /3.2.9.1 \(protocol version: 2.0\)/ ){
+                        $found_version = 1;
+                }
+        }
+        cmp_ok($found_version, '==', 1, "Output OK");
         close NC;
 
         open(NC, "echo 'SSH-2.0-nagiosplug.ssh.0.1 this is a comment' | nc ${nc_flags} |");
         sleep 0.1;
-        $res = NPTest->testCmd( "./check_ssh -H localhost -p 5003 -r nagiosplug.ssh.0.1" );
-        cmp_ok( $res->return_code, '==', 0, "Got SSH protocol version control string, and parsed comment appropriately");
-        like( $res->output, '/^SSH OK - nagiosplug.ssh.0.1 \(protocol 2.0\)/', "Output OK");
+        $result = NPTest->testCmd( "./check_ssh -H localhost -p 5003 -r nagiosplug.ssh.0.1" ." ". $outputFormat);
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "OK", "State was correct");
+
+        # looking for the version
+        $found_version = 0;
+        for my $subcheck (@{$output->{'checks'}}) {
+                if ($subcheck->{'output'} =~ /nagiosplug.ssh.0.1 \(protocol version: 2.0\)/ ){
+                        $found_version = 1;
+                }
+        }
+        cmp_ok($found_version, '==', 1, "Output OK");
         close NC;
 
         open(NC, "echo 'SSH-' | nc ${nc_flags}|");
         sleep 0.1;
-        $res = NPTest->testCmd( "./check_ssh -H localhost -p 5003" );
-        cmp_ok( $res->return_code, '==', 2, "Got invalid SSH protocol version control string");
-        like( $res->output, '/^SSH CRITICAL/', "Output OK");
+        $result = NPTest->testCmd( "./check_ssh -H localhost -p 5003" ." ". $outputFormat);
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "CRITICAL", "Got invalid SSH protocol version control string");
         close NC;
 
         open(NC, "echo '' | nc ${nc_flags}|");
         sleep 0.1;
-        $res = NPTest->testCmd( "./check_ssh -H localhost -p 5003" );
-        cmp_ok( $res->return_code, '==', 2, "No version control string received");
-        like( $res->output, '/^SSH CRITICAL - No version control string received/', "Output OK");
+        $result = NPTest->testCmd( "./check_ssh -H localhost -p 5003" ." ". $outputFormat);
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "CRITICAL", "No version control string received");
         close NC;
 
         open(NC, "echo 'Not a version control string' | nc ${nc_flags}|");
         sleep 0.1;
-        $res = NPTest->testCmd( "./check_ssh -H localhost -p 5003" );
-        cmp_ok( $res->return_code, '==', 2, "No version control string received");
-        like( $res->output, '/^SSH CRITICAL - No version control string received/', "Output OK");
+        $result = NPTest->testCmd( "./check_ssh -H localhost -p 5003"  ." ". $outputFormat);
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "CRITICAL", "No version control string received");
         close NC;
 
 
@@ -116,8 +158,18 @@ SKIP: {
                 echo 'Some\nPrepended\nData\nLines\n'; sleep 0.2;
                 echo 'SSH-2.0-nagiosplug.ssh.0.2';} | nc ${nc_flags}|");
         sleep 0.1;
-        $res = NPTest->testCmd( "./check_ssh -H localhost -p 5003" );
-        cmp_ok( $res->return_code, '==', 0, "Got delayed SSH protocol version control string");
-        like( $res->output, '/^SSH OK - nagiosplug.ssh.0.2 \(protocol 2.0\)/', "Output OK");
+        $result = NPTest->testCmd( "./check_ssh -H localhost -p 5003" ." ". $outputFormat);
+        cmp_ok($result->return_code, '==', 0, "Exit with return code 0 (OK)");
+        $output = decode_json($result->output);
+        is($output->{'state'}, "OK", "State was correct");
+
+        # looking for the version
+        $found_version = 0;
+        for my $subcheck (@{$output->{'checks'}}) {
+                if ($subcheck->{'output'} =~ /nagiosplug.ssh.0.2 \(protocol version: 2.0\)/ ){
+                        $found_version = 1;
+                }
+        }
+        cmp_ok($found_version, '==', 1, "Output OK");
         close NC;
 }
diff --git a/plugins/t/check_swap.t b/plugins/t/check_swap.t
index eaa81083..68946f6d 100644
--- a/plugins/t/check_swap.t
+++ b/plugins/t/check_swap.t
@@ -5,39 +5,47 @@
 #
 
 use strict;
-use Test::More tests => 14;
+use warnings;
+use Test::More tests => 21;
 use NPTest;
-
-my $successOutput = '/^SWAP OK - [0-9]+\% free \([0-9]+MiB out of [0-9]+MiB\)/';
-my $failureOutput = '/^SWAP CRITICAL - [0-9]+\% free \([0-9]+MiB out of [0-9]+MiB\)/';
-my $warnOutput    = '/^SWAP WARNING - [0-9]+\% free \([0-9]+MiB out of [0-9]+MiB\)/';
+use JSON;
 
 my $result;
+my $outputFormat = '--output-format mp-test-json';
+my $output;
+my $message = '/^[0-9]+\% free \([0-9]+MiB out of [0-9]+MiB\)/';
 
-$result = NPTest->testCmd( "./check_swap" );                                    # Always OK
+$result = NPTest->testCmd( "./check_swap $outputFormat" );                                      # Always OK
 cmp_ok( $result->return_code, "==", 0, "Always OK" );
-like( $result->output, $successOutput, "Right output" );
+is($result->{'mp_test_result'}->{'state'}, "OK", "State was correct");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $message, "Output was correct");
 
-$result = NPTest->testCmd( "./check_swap -w 1048576 -c 1048576" );              # 1 MB free
-cmp_ok( $result->return_code, "==", 0, "At least 1MB free" );
-like( $result->output, $successOutput, "Right output" );
+$result = NPTest->testCmd( "./check_swap -w 1048576 -c 1048576 $outputFormat" );                # 1 MB free
+cmp_ok( $result->return_code, "==", 0, "Always OK" );
+is($result->{'mp_test_result'}->{'state'}, "OK", "State was correct");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $message, "Output was correct");
 
-$result = NPTest->testCmd( "./check_swap -w 1% -c 1%" );                        # 1% free
-cmp_ok( $result->return_code, "==", 0, 'At least 1% free' );
-like( $result->output, $successOutput, "Right output" );
+$result = NPTest->testCmd( "./check_swap -w 1% -c 1% $outputFormat" );                  # 1% free
+cmp_ok( $result->return_code, "==", 0, "Always OK" );
+is($result->{'mp_test_result'}->{'state'}, "OK", "State was correct");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $message, "Output was correct");
 
-$result = NPTest->testCmd( "./check_swap -w 100% -c 100%" );                    # 100% (always critical)
-cmp_ok( $result->return_code, "==", 2, 'Get critical because not 100% free' );
-like( $result->output, $failureOutput, "Right output" );
+$result = NPTest->testCmd( "./check_swap -w 100% -c 100% $outputFormat" );                      # 100% (always critical)
+cmp_ok( $result->return_code, "==", 0, "Always OK" );
+is($result->{'mp_test_result'}->{'state'}, "CRITICAL", "State was correct");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $message, "Output was correct");
 
-$result = NPTest->testCmd( "./check_swap -w 100% -c 1%" );                      # 100% (always warn)
-cmp_ok( $result->return_code, "==", 1, 'Get warning because not 100% free' );
-like( $result->output, $warnOutput, "Right output" );
+$result = NPTest->testCmd( "./check_swap -w 100% -c 1% $outputFormat" );                        # 100% (always warn)
+cmp_ok( $result->return_code, "==", 0, "Always OK" );
+is($result->{'mp_test_result'}->{'state'}, "WARNING", "State was correct");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $message, "Output was correct");
 
-$result = NPTest->testCmd( "./check_swap -w 100%" );                            # 100% (single threshold, always warn)
-cmp_ok( $result->return_code, "==", 1, 'Get warning because not 100% free' );
-like( $result->output, $warnOutput, "Right output" );
+$result = NPTest->testCmd( "./check_swap -w 100% $outputFormat" );                              # 100% (single threshold, always warn)
+cmp_ok( $result->return_code, "==", 0, "Always OK" );
+is($result->{'mp_test_result'}->{'state'}, "WARNING", "State was correct");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $message, "Output was correct");
 
-$result = NPTest->testCmd( "./check_swap -c 100%" );                            # 100% (single threshold, always critical)
-cmp_ok( $result->return_code, "==", 2, 'Get critical because not 100% free' );
-like( $result->output, $failureOutput, "Right output" );
+$result = NPTest->testCmd( "./check_swap -c 100% $outputFormat" );                              # 100% (single threshold, always critical)
+cmp_ok( $result->return_code, "==", 0, "Always OK" );
+is($result->{'mp_test_result'}->{'state'}, "CRITICAL", "State was correct");
+like($result->{'mp_test_result'}->{'checks'}->[0]->{'output'}, $message, "Output was correct");
diff --git a/plugins/t/check_tcp.t b/plugins/t/check_tcp.t
index cb4de53d..5c8fd0be 100644
--- a/plugins/t/check_tcp.t
+++ b/plugins/t/check_tcp.t
@@ -21,19 +21,19 @@ my $host_nonresponsive = getTestParameter("NP_HOST_NONRESPONSIVE", "The hostname
 my $hostname_invalid   = getTestParameter("NP_HOSTNAME_INVALID", "An invalid (not known to DNS) hostname", "nosuchhost");
 my $internet_access    = getTestParameter("NP_INTERNET_ACCESS", "Is this system directly connected to the internet?", "yes");
 
-my $successOutput = '/^TCP OK\s-\s+[0-9]?\.?[0-9]+ second response time on port [0-9]+/';
+my $successOutput = '/Connection time\s+[0-9]?\.?[0-9]+s is within thresholds+/';
 
-my $failedExpect = '/^TCP WARNING\s-\sUnexpected response from host/socket on port [0-9]+/';
+my $failedExpect = '/Answer failed to match/';
 
 my $t;
 
 $tests = $tests - 4 if $internet_access eq "no";
 plan tests => $tests;
 
-$t += checkCmd( "./check_tcp $host_tcp_http      -p 80 -wt 300 -ct 600",       0, $successOutput );
-$t += checkCmd( "./check_tcp $host_tcp_http      -p 81 -wt   0 -ct   0 -to 1", 2 ); # use invalid port for this test
-$t += checkCmd( "./check_tcp $host_nonresponsive -p 80 -wt   0 -ct   0 -to 1", 2 );
-$t += checkCmd( "./check_tcp $hostname_invalid   -p 80 -wt   0 -ct   0 -to 1", 2 );
+$t += checkCmd( "./check_tcp $host_tcp_http      -p 80 -w 300 -c 600",       0, $successOutput );
+$t += checkCmd( "./check_tcp $host_tcp_http      -p 81 -w   0 -c   0 -t 1", 2 ); # use invalid port for this test
+$t += checkCmd( "./check_tcp $host_nonresponsive -p 80 -w   0 -c   0 -t 1", 2 );
+$t += checkCmd( "./check_tcp $hostname_invalid   -p 80 -w   0 -c   0 -t 1", 2 );
 if($internet_access ne "no") {
     $t += checkCmd( "./check_tcp -S -D 1 -H $host_tls_http -p 443",              0 );
     $t += checkCmd( "./check_tcp -S -D 9000,1    -H $host_tls_http -p 443",      1 );
diff --git a/plugins/t/check_udp.t b/plugins/t/check_udp.t
index 6c47d095..5cb9e6dc 100644
--- a/plugins/t/check_udp.t
+++ b/plugins/t/check_udp.t
@@ -28,7 +28,7 @@ like  ( $res->output, '/With UDP checks, a send/expect string must be specified.
 
 $res = NPTest->testCmd( "./check_udp -H localhost -p 3333 -s foo -e bar" );
 cmp_ok( $res->return_code, '==', 2, "Errors correctly because no udp service running" );
-like  ( $res->output, '/No data received from host/', "Output OK");
+like  ( $res->output, '/Received no data /', "Output OK");
 
 my $nc;
 if(system("which nc.traditional >/dev/null 2>&1") == 0) {
@@ -48,7 +48,7 @@ SKIP: {
         sleep 1;
         $res = NPTest->testCmd( "./check_udp -H localhost -p 3333 -s '' -e barbar -4" );
         cmp_ok( $res->return_code, '==', 0, "Got barbar response back" );
-        like  ( $res->output, '/\[barbar\]/', "Output OK");
+        like  ( $res->output, '/answer of the server matched/', "Output OK");
         close NC;
 
         # Start up a udp server listening on port 3333, quit after 3 seconds