renamed module into Monitoring::Plugin

since the complete monitoring team has been renamed, we
also rename this module.

Signed-off-by: Sven Nierlein <sven@nierlein.de>

23 files changed, 564 insertions, 584 deletions

diff --git a/t/Nagios-Plugin-01.t b/t/Monitoring-Plugin-01.t
index 947a704..f5882a5 100644
--- a/t/Nagios-Plugin-01.t
+++ b/t/Monitoring-Plugin-01.t
@@ -1,32 +1,32 @@
-# Nagios::Plugin original test cases
+# Monitoring::Plugin original test cases
 
 use strict;
 use Test::More tests => 15;
 
-BEGIN { use_ok('Nagios::Plugin') };
+BEGIN { use_ok('Monitoring::Plugin') };
 
-use Nagios::Plugin::Functions;
-Nagios::Plugin::Functions::_fake_exit(1);
+use Monitoring::Plugin::Functions;
+Monitoring::Plugin::Functions::_fake_exit(1);
 
-diag "\nusing Nagios::Plugin revision ". $Nagios::Plugin::VERSION . "\n"
+diag "\nusing Monitoring::Plugin revision ". $Monitoring::Plugin::VERSION . "\n"
   if $ENV{TEST_VERBOSE};
 
-my $p = Nagios::Plugin->new();
-isa_ok( $p, "Nagios::Plugin");
+my $p = Monitoring::Plugin->new();
+isa_ok( $p, "Monitoring::Plugin");
 
 $p->shortname("PAGESIZE");
 is($p->shortname, "PAGESIZE", "shortname explicitly set correctly");
 
-$p = Nagios::Plugin->new();
-is($p->shortname, "NAGIOS-PLUGIN-01", "shortname should default on new");
+$p = Monitoring::Plugin->new();
+is($p->shortname, "MONITORING-PLUGIN-01", "shortname should default on new");
 
-$p = Nagios::Plugin->new( shortname => "SIZE", () );
+$p = Monitoring::Plugin->new( shortname => "SIZE", () );
 is($p->shortname, "SIZE", "shortname set correctly on new");
 
-$p = Nagios::Plugin->new( plugin => "check_stuff", () );
+$p = Monitoring::Plugin->new( plugin => "check_stuff", () );
 is($p->shortname, "STUFF", "shortname uses plugin name as default");
 
-$p = Nagios::Plugin->new(  shortname => "SIZE", plugin => "check_stuff", () );
+$p = Monitoring::Plugin->new(  shortname => "SIZE", plugin => "check_stuff", () );
 is($p->shortname, "SIZE", "shortname is not overriden by default");
 
 diag "warn if < 10, critical if > 25 " if $ENV{TEST_VERBOSE};
@@ -37,10 +37,10 @@ use Data::Dumper;
 #diag "dumping perfdata:  ". Dumper $p->perfdata;
 
 
-$p->add_perfdata( 
-        label => "size", 
-        value => 1, 
-        uom => "kB", 
+$p->add_perfdata(
+        label => "size",
+        value => 1,
+        uom => "kB",
         threshold => $t,
         );
 
@@ -69,4 +69,3 @@ foreach (sort {$a<=>$b} keys %$expected) {
          qr/$expected->{$_}/,
         "Output okay. $_ = $expected->{$_}" ;
 }
-
diff --git a/t/Monitoring-Plugin-02.t b/t/Monitoring-Plugin-02.t
new file mode 100644
index 0000000..6cc834d
--- /dev/null
+++ b/t/Monitoring-Plugin-02.t
@@ -0,0 +1,160 @@
+# Monitoring::Plugin test set 2, testing MP::Functions wrapping
+
+use strict;
+use Test::More tests => 103;
+
+BEGIN { use_ok("Monitoring::Plugin") }
+require Monitoring::Plugin::Functions;
+Monitoring::Plugin::Functions::_fake_exit(1);
+
+# Hardcoded checks of constants
+my %ERRORS = %Monitoring::Plugin::Functions::ERRORS;
+is(OK,          $ERRORS{OK},            "OK        => $ERRORS{OK}");
+is(WARNING,     $ERRORS{WARNING},       "WARNING   => $ERRORS{WARNING}");
+is(CRITICAL,    $ERRORS{CRITICAL},      "CRITICAL  => $ERRORS{CRITICAL}");
+is(UNKNOWN,     $ERRORS{UNKNOWN},       "UNKNOWN   => $ERRORS{UNKNOWN}");
+is(DEPENDENT,   $ERRORS{DEPENDENT},     "DEPENDENT => $ERRORS{DEPENDENT}");
+
+my $plugin = 'TEST_PLUGIN';
+my $np = Monitoring::Plugin->new( shortname => $plugin );
+is($np->shortname, $plugin, "shortname() is $plugin");
+
+# Test plugin_exit( CONSTANT, $msg ), plugin_exit( $string, $msg )
+my $r;
+my @ok = (
+    [ OK,        "OK",           'test the first',  ],
+    [ WARNING,   "WARNING",      'test the second', ],
+    [ CRITICAL,  "CRITICAL",     'test the third',  ],
+    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
+    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
+);
+for (@ok) {
+    # CONSTANT
+    $r = $np->plugin_exit($_->[0], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_exit(%s, $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$plugin\b.*$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_exit(%s, $msg) output matched "%s"', $_->[1],
+            $plugin . ' ' . $_->[1] . '.*' . $_->[2]));
+
+    # $string
+    $r = $np->plugin_exit($_->[1], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_exit("%s", $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$plugin\b.*$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_exit("%s", $msg) output matched "%s"', $_->[1],
+            $plugin . ' ' . $_->[1] . '.*' . $_->[2]));
+    like($r, qr/$plugin\b.*$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_exit("%s", $msg) stringified matched "%s"', $_->[1],
+            $plugin . ' ' . $_->[1] . '.*' . $_->[2]));
+}
+
+# plugin_exit code corner cases
+my @ugly1 = (
+    [ -1, 'testing code -1' ],
+    [ 7, 'testing code 7' ],
+    [ undef, 'testing code undef' ],
+    [ '', qq(testing code '') ],
+    [ 'string', qq(testing code 'string') ],
+);
+for (@ugly1) {
+    $r = $np->plugin_exit($_->[0], $_->[1]);
+    my $display = defined $_->[0] ? "'$_->[0]'" : 'undef';
+    is($r->return_code, UNKNOWN, "plugin_exit($display, \$msg) returned ". UNKNOWN);
+    like($r->message, qr/UNKNOWN\b.*\b$_->[1]$/,
+        sprintf('plugin_exit(%s, $msg) output matched "%s"',
+            $display, 'UNKNOWN.*' . $_->[1]));
+}
+
+# plugin_exit message corner cases
+my @ugly2 = (
+    [ '' ],
+    [ undef ],
+    [ UNKNOWN ],
+);
+for (@ugly2) {
+    $r = $np->plugin_exit(CRITICAL, $_->[0]);
+    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
+    my $display2 = defined $_->[0] ? $_->[0] : '';
+    like($r->message, qr/CRITICAL\b.*\b$display2$/,
+        sprintf('plugin_exit(%s, $msg) output matched "%s"',
+            $display1, "CRITICAL.*$display2"));
+}
+
+# Test plugin_die( $msg )
+my @msg = (
+    [ 'die you dog' ],
+    [ '' ],
+    [ undef ],
+);
+for (@msg) {
+    $r = $np->plugin_die($_->[0]);
+    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
+    my $display2 = defined $_->[0] ? $_->[0] : '';
+    is($r->return_code, UNKNOWN,
+        sprintf('plugin_die(%s) returned UNKNOWN', $display1));
+    like($r->message, qr/UNKNOWN\b.*\b$display2$/,
+        sprintf('plugin_die(%s) output matched "%s"', $display1,
+            "UNKNOWN.*$display2"));
+}
+
+# Test plugin_die( CONSTANT, $msg ), plugin_die( $msg, CONSTANT ),
+#   plugin_die( $string, $msg ), and plugin_die( $msg, $string )
+@ok = (
+    [ OK,        "OK",           'test the first',  ],
+    [ WARNING,   "WARNING",      'test the second', ],
+    [ CRITICAL,  "CRITICAL",     'test the third',  ],
+    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
+    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
+);
+for (@ok) {
+    # CONSTANT, $msg
+    $r = $np->plugin_die($_->[0], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die(%s, $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die(%s, $msg) output matched "%s"',
+            $_->[1], $_->[1] . '.*' . $_->[2]));
+
+    # $msg, CONSTANT
+    $r = $np->plugin_die($_->[2], $_->[0]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die($msg, %s) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die($msg, %s) output matched "%s"',
+            $_->[1], $_->[1] . '.*' . $_->[2]));
+
+    # $string, $msg
+    $r = $np->plugin_die($_->[1], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die("%s", $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die("%s", $msg) output matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+    like($r, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die("%s", $msg) stringified matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+
+    # $string, $msg
+    $r = $np->plugin_die($_->[2], $_->[1]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die($msg, "%s") returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die($msg, "%s") output matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+    like($r, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die($msg, "%s") stringified matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+}
+
+
+# shortname testing
+SKIP: {
+    skip "requires File::Basename", 2 unless eval { require File::Basename };
+    $np = Monitoring::Plugin->new( version => "1");
+    $plugin = uc File::Basename::basename($0);
+    $plugin =~ s/\..*$//;
+    is($np->shortname, $plugin, "shortname() is '$plugin'");
+    $r = $np->plugin_exit(OK, "foobar");
+    like($r->message, qr/^$plugin OK/, "message begins with '$plugin OK'");
+}
diff --git a/t/Nagios-Plugin-03.t b/t/Monitoring-Plugin-03.t
index bc4f5e3..d419342 100644
--- a/t/Nagios-Plugin-03.t
+++ b/t/Monitoring-Plugin-03.t
@@ -3,15 +3,15 @@
 use strict;
 use Test::More tests => 61;
 
-BEGIN { 
-    use_ok("Nagios::Plugin");
-    use_ok("Nagios::Plugin::Functions", ":all");
+BEGIN {
+    use_ok("Monitoring::Plugin");
+    use_ok("Monitoring::Plugin::Functions", ":all");
 }
-Nagios::Plugin::Functions::_fake_exit(1);
+Monitoring::Plugin::Functions::_fake_exit(1);
 
-my $plugin = 'NP_CHECK_MESSAGES_03';
-my $np = Nagios::Plugin->new( shortname => $plugin, () );
-is($np->shortname, $plugin, "shortname() is $plugin"); 
+my $plugin = 'MP_CHECK_MESSAGES_03';
+my $np = Monitoring::Plugin->new( shortname => $plugin, () );
+is($np->shortname, $plugin, "shortname() is $plugin");
 
 my ($code, $message);
 
@@ -113,11 +113,11 @@ is($message, join(' ', @{$arrays{ok}}), "joined undef (ok) message is $message")
 # -------------------------------------------------------------------------
 # join_all messages
 my $join_all = ' :: ';
-my $msg_all_cwo = join($join_all, map { join(' ', @{$arrays{$_}}) } 
+my $msg_all_cwo = join($join_all, map { join(' ', @{$arrays{$_}}) }
     qw(critical warning ok));
-my $msg_all_cw = join($join_all, map { join(' ', @{$arrays{$_}}) } 
+my $msg_all_cw = join($join_all, map { join(' ', @{$arrays{$_}}) }
     qw(critical warning));
-my $msg_all_wo = join($join_all, map { join(' ', @{$arrays{$_}}) } 
+my $msg_all_wo = join($join_all, map { join(' ', @{$arrays{$_}}) }
     qw(warning ok));
 
 # critical, warning, ok
@@ -172,33 +172,33 @@ is($message, 'D E F', "join_all '$join_all' (critical, warning) message is $mess
 # add_messages
 
 # Constant codes
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( CRITICAL, "A B C" );
 $np->add_message( WARNING, "D E F" );
 ($code, $message) = $np->check_messages();
 is($code, CRITICAL, "(CRITICAL, WARNING) code is $STATUS_TEXT{$code}");
 is($message, $messages{critical}, "(CRITICAL, WARNING) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( CRITICAL, "A B C" );
 ($code, $message) = $np->check_messages();
 is($code, CRITICAL, "(CRITICAL) code is $STATUS_TEXT{$code}");
 is($message, $messages{critical}, "(CRITICAL) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( WARNING, "D E F" );
 ($code, $message) = $np->check_messages();
 is($code, WARNING, "(WARNING) code is $STATUS_TEXT{$code}");
 is($message, $messages{warning}, "(WARNING) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( WARNING, "D E F" );
 $np->add_message( OK, "G H I" );
 ($code, $message) = $np->check_messages();
 is($code, WARNING, "(WARNING, OK) code is $STATUS_TEXT{$code}");
 is($message, $messages{warning}, "(WARNING, OK) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( OK, "G H I" );
 ($code, $message) = $np->check_messages();
 is($code, OK, "(OK) code is $STATUS_TEXT{$code}");
@@ -206,33 +206,33 @@ is($message, $messages{ok}, "(OK) message is $message");
 
 
 # String codes
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( critical => "A B C" );
 $np->add_message( warning => "D E F" );
 ($code, $message) = $np->check_messages();
 is($code, CRITICAL, "(critical, warning) code is $STATUS_TEXT{$code}");
 is($message, $messages{critical}, "(critical, warning) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( critical => "A B C" );
 ($code, $message) = $np->check_messages();
 is($code, CRITICAL, "(critical) code is $STATUS_TEXT{$code}");
 is($message, $messages{critical}, "(critical) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( warning => "D E F" );
 ($code, $message) = $np->check_messages();
 is($code, WARNING, "(warning) code is $STATUS_TEXT{$code}");
 is($message, $messages{warning}, "(warning) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( warning => "D E F" );
 $np->add_message( ok => "G H I" );
 ($code, $message) = $np->check_messages();
 is($code, WARNING, "(warning, ok) code is $STATUS_TEXT{$code}");
 is($message, $messages{warning}, "(warning, ok) message is $message");
 
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 $np->add_message( ok => "G H I" );
 ($code, $message) = $np->check_messages();
 is($code, OK, "(ok) code is $STATUS_TEXT{$code}");
@@ -240,7 +240,7 @@ is($message, $messages{ok}, "(ok) message is $message");
 
 
 # No add_message
-$np = Nagios::Plugin->new();
+$np = Monitoring::Plugin->new();
 ($code, $message) = $np->check_messages();
 is($code, OK, "() code is $STATUS_TEXT{$code}");
 is($message, '', "() message is ''");
@@ -250,14 +250,13 @@ is($message, '', "() message is ''");
 # Error conditions
 
 # add_message errors
-$np = Nagios::Plugin->new();
-ok(! defined eval { $np->add_message( foobar => 'hi mum' ) }, 
+$np = Monitoring::Plugin->new();
+ok(! defined eval { $np->add_message( foobar => 'hi mum' ) },
     'add_message dies on invalid code');
-ok(! defined eval { $np->add_message( OKAY => 'hi mum' ) }, 
+ok(! defined eval { $np->add_message( OKAY => 'hi mum' ) },
     'add_message dies on invalid code');
 # UNKNOWN and DEPENDENT error codes
-ok(! defined eval { $np->add_message( unknown => 'hi mum' ) }, 
+ok(! defined eval { $np->add_message( unknown => 'hi mum' ) },
     'add_message dies on UNKNOWN code');
-ok(! defined eval { $np->add_message( dependent => 'hi mum' ) }, 
+ok(! defined eval { $np->add_message( dependent => 'hi mum' ) },
     'add_message dies on DEPENDENT code');
-
diff --git a/t/Nagios-Plugin-04.t b/t/Monitoring-Plugin-04.t
index e5eb3ab..41027f7 100644
--- a/t/Nagios-Plugin-04.t
+++ b/t/Monitoring-Plugin-04.t
@@ -5,25 +5,25 @@ use strict;
 #use Test::More 'no_plan';
 use Test::More tests=>30;
 
-BEGIN { use_ok('Nagios::Plugin') };
-use Nagios::Plugin::Functions;
-Nagios::Plugin::Functions::_fake_exit(1);
+BEGIN { use_ok('Monitoring::Plugin') };
+use Monitoring::Plugin::Functions;
+Monitoring::Plugin::Functions::_fake_exit(1);
 
 
-eval { Nagios::Plugin->new(); };
+eval { Monitoring::Plugin->new(); };
 ok(! $@, "constructor DOESN'T die without usage");
 
-my $p = Nagios::Plugin->new();
+my $p = Monitoring::Plugin->new();
 eval { $p->add_arg('warning', 'warning') };
 ok($@, "add_arg() dies if you haven't instantiated with usage");
 eval { $p->getopts };
 ok($@, "getopts() dies if you haven't instantiated with usage");
 
-$p = Nagios::Plugin->new( usage => "dummy usage statement" );
+$p = Monitoring::Plugin->new( usage => "dummy usage statement" );
 
 # option accessors work
 can_ok $p, 'opts';
-isa_ok $p->opts, 'Nagios::Plugin::Getopt', "Getopt object is defined";
+isa_ok $p->opts, 'Monitoring::Plugin::Getopt', "Getopt object is defined";
 
 $p->add_arg('warning|w=s', "warning");
 $p->add_arg('critical|c=s', "critical");
@@ -35,11 +35,11 @@ is $p->opts->critical, "10", "critical opt is accessible";
 
 
 can_ok $p, 'perfdata';
-#isa_ok $p->perfdata, 'Nagios::Plugin::Performance', "perfdata object is defined";
+#isa_ok $p->perfdata, 'Monitoring::Plugin::Performance', "perfdata object is defined";
 
 
 can_ok $p, 'threshold';
-#isa_ok $p->threshold, 'Nagios::Plugin::Threshold', "threshold object is defined";
+#isa_ok $p->threshold, 'Monitoring::Plugin::Threshold', "threshold object is defined";
 
 
 eval { $p->check_threshold() };
@@ -60,20 +60,20 @@ is $p->check_threshold(check=>[1,2,6,11]), CRITICAL, "check_threshold CRITICAL w
 
 # thresholds set explicitly
 is $p->check_threshold(
-                                           check    => 2, 
+                                           check    => 2,
                                            warning  => 50,
                                            critical => 100
 ), OK, "check_threshold explicit OK";
 
 is $p->check_threshold(
-                                           check    => 66, 
+                                           check    => 66,
                                            warning  => 50,
                                            critical => 100
 ), WARNING, "check_threshold explicit WARNING";
 
 
 is $p->check_threshold(
-                                           check    => -1, 
+                                           check    => -1,
                                            warning  => 5,
                                            critical => '0:5',
 ), CRITICAL, "check_threshold explicit CRITICAL";
@@ -82,7 +82,7 @@ is $p->check_threshold(
 
 # what happens if you forget to define warning or critical thresholds?
 $p = undef;
-$p = Nagios::Plugin->new();
+$p = Monitoring::Plugin->new();
 
 is $p->check_threshold(2), UNKNOWN, "everything is now UNKNOWN";
 is $p->check_threshold(-200), UNKNOWN, "everything is now UNKNOWN";
diff --git a/t/Nagios-Plugin-05.t b/t/Monitoring-Plugin-05.t
index cc602cc..d17464f 100644
--- a/t/Nagios-Plugin-05.t
+++ b/t/Monitoring-Plugin-05.t
@@ -1,16 +1,15 @@
 # Check for exported vars
-# Can't include Nagios::Plugin::Functions because it also exports %STATUS_TEXT
+# Can't include Monitoring::Plugin::Functions because it also exports %STATUS_TEXT
 
 use strict;
 use Test::More tests=>4;
 
-BEGIN { use_ok('Nagios::Plugin') };
+BEGIN { use_ok('Monitoring::Plugin') };
 
 eval ' $_ = $STATUS_TEXT{0} ';
 like( $@, '/Global symbol "%STATUS_TEXT" requires explicit package name/' );
 
-use_ok("Nagios::Plugin", qw(%STATUS_TEXT));
+use_ok("Monitoring::Plugin", qw(%STATUS_TEXT));
 
 eval ' $_ = $STATUS_TEXT{0} ';
 is( $@, '' );
-
diff --git a/t/Monitoring-Plugin-Functions-01.t b/t/Monitoring-Plugin-Functions-01.t
new file mode 100644
index 0000000..084ad28
--- /dev/null
+++ b/t/Monitoring-Plugin-Functions-01.t
@@ -0,0 +1,161 @@
+
+use strict;
+use Test::More tests => 113;
+
+BEGIN { use_ok("Monitoring::Plugin::Functions", ":all"); }
+Monitoring::Plugin::Functions::_fake_exit(1);
+
+my $this_version=$Monitoring::Plugin::Functions::VERSION;
+foreach my $m ("", qw(::Threshold ::Getopt ::Performance ::Range)) {
+        my $mod = "Monitoring::Plugin$m";
+        use_ok($mod);
+        # Lots of hackery below. Easier to say $mod->VERSION, but this is probably a recent perl thing
+        my $v = "$mod"."::VERSION";
+        my $a = eval "\$$v";
+        is($a, $this_version, "Version number for $mod the same as Functions: $this_version");
+}
+
+# check get_shortname
+is(get_shortname, "MONITORING-PLUGIN-FUNCTIONS-01", "get_shortname ok");
+
+# Hardcoded checks of constants
+ok(%ERRORS, '%ERRORS defined');
+is(OK,          $ERRORS{OK},            "OK        => $ERRORS{OK}");
+is(WARNING,     $ERRORS{WARNING},       "WARNING   => $ERRORS{WARNING}");
+is(CRITICAL,    $ERRORS{CRITICAL},      "CRITICAL  => $ERRORS{CRITICAL}");
+is(UNKNOWN,     $ERRORS{UNKNOWN},       "UNKNOWN   => $ERRORS{UNKNOWN}");
+is(DEPENDENT,   $ERRORS{DEPENDENT},     "DEPENDENT => $ERRORS{DEPENDENT}");
+
+# Test plugin_exit( CONSTANT, $msg ), plugin_exit( $string, $msg )
+my $r;
+my @ok = (
+    [ OK,        "OK",           'test the first',  ],
+    [ WARNING,   "WARNING",      'test the second', ],
+    [ CRITICAL,  "CRITICAL",     'test the third',  ],
+    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
+    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
+);
+for (@ok) {
+    # CONSTANT
+    $r = plugin_exit($_->[0], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_exit(%s, $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_exit(%s, $msg) output matched "%s"',
+            $_->[1], $_->[1] . '.*' . $_->[2]));
+
+    # $string
+    $r = plugin_exit($_->[1], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_exit("%s", $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_exit("%s", $msg) output matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+    like($r, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_exit("%s", $msg) stringified matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+}
+
+# plugin_exit code corner cases
+my @ugly1 = (
+    [ -1, 'testing code -1' ],
+    [ 7, 'testing code 7' ],
+    [ undef, 'testing code undef' ],
+    [ '', qq(testing code '') ],
+    [ 'string', qq(testing code 'string') ],
+);
+for (@ugly1) {
+    $r = plugin_exit($_->[0], $_->[1]);
+    my $display = defined $_->[0] ? "'$_->[0]'" : 'undef';
+    is($r->return_code, UNKNOWN, "plugin_exit($display, \$msg) returned ". UNKNOWN);
+    like($r->message, qr/UNKNOWN\b.*\b$_->[1]$/,
+        sprintf('plugin_exit(%s, $msg) output matched "%s"',
+            $display, 'UNKNOWN.*' . $_->[1]));
+}
+
+# plugin_exit message corner cases
+my @ugly2 = (
+    [ '' ],
+    [ undef ],
+    [ UNKNOWN ],
+);
+for (@ugly2) {
+    $r = plugin_exit(CRITICAL, $_->[0]);
+    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
+    my $display2 = defined $_->[0] ? $_->[0] : '';
+    like($r->message, qr/CRITICAL\b.*\b$display2$/,
+        sprintf('plugin_exit(%s, $msg) output matched "%s"',
+            $display1, "CRITICAL.*$display2"));
+}
+
+# Test plugin_die( $msg )
+my @msg = (
+    [ 'die you dog' ],
+    [ '' ],
+    [ undef ],
+);
+for (@msg) {
+    $r = plugin_die($_->[0]);
+    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
+    my $display2 = defined $_->[0] ? $_->[0] : '';
+    is($r->return_code, UNKNOWN,
+        sprintf('plugin_die(%s) returned UNKNOWN', $display1));
+    like($r->message, qr/UNKNOWN\b.*\b$display2$/,
+        sprintf('plugin_die(%s) output matched "%s"', $display1,
+            "UNKNOWN.*$display2"));
+}
+
+# Test plugin_die( CONSTANT, $msg ), plugin_die( $msg, CONSTANT ),
+#   plugin_die( $string, $msg ), and plugin_die( $msg, $string )
+@ok = (
+    [ OK,        "OK",           'test the first',  ],
+    [ WARNING,   "WARNING",      'test the second', ],
+    [ CRITICAL,  "CRITICAL",     'test the third',  ],
+    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
+    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
+);
+for (@ok) {
+    # CONSTANT, $msg
+    $r = plugin_die($_->[0], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die(%s, $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die(%s, $msg) output matched "%s"',
+            $_->[1], $_->[1] . '.*' . $_->[2]));
+
+    # $msg, CONSTANT
+    $r = plugin_die($_->[2], $_->[0]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die($msg, %s) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die($msg, %s) output matched "%s"',
+            $_->[1], $_->[1] . '.*' . $_->[2]));
+
+    # $string, $msg
+    $r = plugin_die($_->[1], $_->[2]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die("%s", $msg) returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die("%s", $msg) output matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+    like($r, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die("%s", $msg) stringified matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+
+    # $string, $msg
+    $r = plugin_die($_->[2], $_->[1]);
+    is($r->return_code, $_->[0],
+        sprintf('plugin_die($msg, "%s") returned %s', $_->[1], $_->[0]));
+    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die($msg, "%s") output matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+    like($r, qr/$_->[1]\b.*\b$_->[2]$/,
+        sprintf('plugin_die($msg, "%s") stringified matched "%s"', $_->[1],
+            $_->[1] . '.*' . $_->[2]));
+}
+
+# Check that _use_die set to 1 will catch exceptions correctly
+Monitoring::Plugin::Functions::_fake_exit(0);
+Monitoring::Plugin::Functions::_use_die(1);
+eval { plugin_die("Using die") };
+is( $@, "MONITORING-PLUGIN-FUNCTIONS-01 UNKNOWN - Using die\n", "Caught exception");
diff --git a/t/Nagios-Plugin-Functions-02.t b/t/Monitoring-Plugin-Functions-02.t
index 1a9351b..3796210 100644
--- a/t/Nagios-Plugin-Functions-02.t
+++ b/t/Monitoring-Plugin-Functions-02.t
@@ -3,7 +3,7 @@
 use strict;
 use Test::More tests => 37;
 
-BEGIN { use_ok("Nagios::Plugin::Functions", ":all") }
+BEGIN { use_ok("Monitoring::Plugin::Functions", ":all") }
 
 my ($code, $message);
 
@@ -105,11 +105,11 @@ is($message, join(' ', @{$arrays{ok}}), "joined undef (ok) message is $message")
 # -------------------------------------------------------------------------
 # join_all messages
 my $join_all = ' :: ';
-my $msg_all_cwo = join($join_all, map { join(' ', @{$arrays{$_}}) } 
+my $msg_all_cwo = join($join_all, map { join(' ', @{$arrays{$_}}) }
     qw(critical warning ok));
-my $msg_all_cw = join($join_all, map { join(' ', @{$arrays{$_}}) } 
+my $msg_all_cw = join($join_all, map { join(' ', @{$arrays{$_}}) }
     qw(critical warning));
-my $msg_all_wo = join($join_all, map { join(' ', @{$arrays{$_}}) } 
+my $msg_all_wo = join($join_all, map { join(' ', @{$arrays{$_}}) }
     qw(warning ok));
 
 # critical, warning, ok
@@ -175,4 +175,3 @@ ok(! defined eval { ($code, $message) = check_messages(critical => $arrays{criti
 
 ok(defined eval { ($code, $message) = check_messages(critical => $arrays{critical}, warning => $arrays{warning}) },
     "check_messages ok with 'critical' and 'warning' messages");
-
diff --git a/t/Nagios-Plugin-Functions-03.t b/t/Monitoring-Plugin-Functions-03.t
index 3706e4c..9f0a62c 100644
--- a/t/Nagios-Plugin-Functions-03.t
+++ b/t/Monitoring-Plugin-Functions-03.t
@@ -3,7 +3,7 @@
 use strict;
 use Test::More tests => 8;
 
-BEGIN { use_ok("Nagios::Plugin::Functions", ":all") }
+BEGIN { use_ok("Monitoring::Plugin::Functions", ":all") }
 
 my $new_state = max_state( OK, WARNING );
 
diff --git a/t/Nagios-Plugin-Functions-04.t b/t/Monitoring-Plugin-Functions-04.t
index d3ff05c..0a7c4e4 100644
--- a/t/Nagios-Plugin-Functions-04.t
+++ b/t/Monitoring-Plugin-Functions-04.t
@@ -3,7 +3,7 @@
 use strict;
 use Test::More tests => 8;
 
-BEGIN { use_ok("Nagios::Plugin::Functions", ":all") }
+BEGIN { use_ok("Monitoring::Plugin::Functions", ":all") }
 
 my $new_state = max_state_alt( OK, WARNING );
 
diff --git a/t/Nagios-Plugin-Getopt-01.t b/t/Monitoring-Plugin-Getopt-01.t
index 7076d75..36f1f55 100644
--- a/t/Nagios-Plugin-Getopt-01.t
+++ b/t/Monitoring-Plugin-Getopt-01.t
@@ -1,33 +1,33 @@
-# Nagios::Plugin::Getopt basic tests
+# Monitoring::Plugin::Getopt basic tests
 
 use strict;
 
 use Test::More tests => 76;
-BEGIN { use_ok('Nagios::Plugin::Getopt') };
+BEGIN { use_ok('Monitoring::Plugin::Getopt') };
 
 # Needed to get evals to work in testing
-Nagios::Plugin::Functions::_use_die(1);
+Monitoring::Plugin::Functions::_use_die(1);
 
 my %PARAM = (
     version => '0.01',
     url => 'http://www.openfusion.com.au/labs/nagios/',
-    blurb => 'This plugin tests various stuff.', 
-    usage => "Usage: %s -H <host> -w <warning_threshold> 
+    blurb => 'This plugin tests various stuff.',
+    usage => "Usage: %s -H <host> -w <warning_threshold>
   -c <critical threshold>",
     plugin => 'test_plugin',
 );
 
-sub setup 
+sub setup
 {
   # Instantiate object
-  my $ng = Nagios::Plugin::Getopt->new(%PARAM);
+  my $ng = Monitoring::Plugin::Getopt->new(%PARAM);
   ok($ng, 'constructor ok');
 
   # Add argument - short form - arg spec, help text, default, required?
   $ng->arg('warning|w=s' =>
     qq(-w, --warning=INTEGER\n   Exit with WARNING status if less than INTEGER foobars are free),
     5);
-  
+
   # Add argument - named version
   $ng->arg(
     spec => 'critical|c=i',
@@ -147,4 +147,3 @@ like($@, qr/--verbose/, 'help includes default options 2');
 like($@, qr/--warning/, 'help includes custom option 1');
 like($@, qr/-c, --critical=INTEGER/, 'help includes custom option 2, with expanded args');
 unlike($@, qr/Missing arg/, 'no missing arguments');
-
diff --git a/t/Nagios-Plugin-Getopt-02.t b/t/Monitoring-Plugin-Getopt-02.t
index f83b180..c6c563e 100644
--- a/t/Nagios-Plugin-Getopt-02.t
+++ b/t/Monitoring-Plugin-Getopt-02.t
@@ -1,27 +1,27 @@
-# Nagios::Plugin::Getopt timeout tests
+# Monitoring::Plugin::Getopt timeout tests
 
 use strict;
 
 use Test::More tests => 14;
-BEGIN { use_ok('Nagios::Plugin::Getopt') };
+BEGIN { use_ok('Monitoring::Plugin::Getopt') };
 
 # Needed to get evals to work in testing
-Nagios::Plugin::Functions::_use_die(1);
+Monitoring::Plugin::Functions::_use_die(1);
 
 my %PARAM = (
     version => '0.01',
     url => 'http://www.openfusion.com.au/labs/nagios/',
-    blurb => 'This plugin tests various stuff.', 
-    usage => "Usage: %s -H <host> -w <warning_threshold> 
+    blurb => 'This plugin tests various stuff.',
+    usage => "Usage: %s -H <host> -w <warning_threshold>
   -c <critical threshold>",
     plugin => 'test_plugin',
     timeout => 18,
 );
 
-sub setup 
+sub setup
 {
   # Instantiate object
-  my $ng = Nagios::Plugin::Getopt->new(%PARAM);
+  my $ng = Monitoring::Plugin::Getopt->new(%PARAM);
   ok($ng, 'constructor ok');
   return $ng;
 }
@@ -61,4 +61,3 @@ alarm($ng->timeout);
 # Loop
 ok(! defined eval { 1 while 1 }, 'loop timed out');
 like($@, qr/UNKNOWN\b.*\btimed out/, 'default timeout handler ok');
-
diff --git a/t/Nagios-Plugin-Getopt-03.t b/t/Monitoring-Plugin-Getopt-03.t
index 560b782..6490145 100644
--- a/t/Nagios-Plugin-Getopt-03.t
+++ b/t/Monitoring-Plugin-Getopt-03.t
@@ -1,4 +1,4 @@
-# Nagios::Plugin::Getopt --extra-opts tests
+# Monitoring::Plugin::Getopt --extra-opts tests
 
 use strict;
 use File::Spec;
@@ -6,15 +6,15 @@ use File::Basename;
 use IO::File;
 
 use Test::More qw(no_plan);
-BEGIN { use_ok('Nagios::Plugin::Getopt') };
+BEGIN { use_ok('Monitoring::Plugin::Getopt') };
 
 # Needed to get evals to work in testing
-Nagios::Plugin::Functions::_use_die(1);
+Monitoring::Plugin::Functions::_use_die(1);
 
 my $tdir = 'npg03';
 if (! -d $tdir) {
   my $ttdir = File::Spec->catdir('t', $tdir);
-  die "missing '$tdir' directory\n" unless -d $ttdir; 
+  die "missing '$tdir' directory\n" unless -d $ttdir;
   $tdir = $ttdir;
 }
 
@@ -30,22 +30,22 @@ for my $efile (glob File::Spec->catfile($tdir, 'expected', '*')) {
   }
 }
 
-# Override NAGIOS_CONFIG_PATH to use our test plugins.ini file
-$ENV{NAGIOS_CONFIG_PATH} = "/random/bogus/path:$tdir";
+# Override MONITORING_CONFIG_PATH to use our test plugins.ini file
+$ENV{MONITORING_CONFIG_PATH} = "/random/bogus/path:$tdir";
 
 my %PARAM = (
     version => '0.01',
-    blurb => 'This plugin tests various stuff.', 
-    usage => "Usage: %s -H <host> -w <warning_threshold> 
+    blurb => 'This plugin tests various stuff.',
+    usage => "Usage: %s -H <host> -w <warning_threshold>
   -c <critical threshold>",
 );
 
-sub ng_setup 
+sub ng_setup
 {
   my $arg = shift;
 
   # Instantiate object
-  my $ng = Nagios::Plugin::Getopt->new(%PARAM);
+  my $ng = Monitoring::Plugin::Getopt->new(%PARAM);
 
   if (ref $arg eq 'ARRAY' && @$arg) {
     $ng->arg(%$_) foreach @$arg;
@@ -54,7 +54,7 @@ sub ng_setup
   return $ng;
 }
 
-# Setup our Nagios::Plugin::Getopt object
+# Setup our Monitoring::Plugin::Getopt object
 my $ng;
 my $arg = [
   { spec => 'S',            help => '-S' },
@@ -85,9 +85,9 @@ for my $infile (glob File::Spec->catfile($tdir, 'input', $glob)) {
     $cmd =~ s/^\s+//;
     my ($plugin, @args) = split /\s+/, $cmd;
 
-    # Fake out the plugin name 
+    # Fake out the plugin name
     $ng->{_attr}->{plugin} = $plugin;
-    
+
     # Parse the options
     SKIP: {
       skip "Skipping ..." if $SKIP{$infile};
@@ -99,10 +99,9 @@ for my $infile (glob File::Spec->catfile($tdir, 'input', $glob)) {
         ok($infile =~ m/_(dies?|catch)$/, "$infile ($@)");
         is($@, $EXPECTED{$infile}, $infile) if ($infile =~ m/_catch$/);
       }
-      else { 
+      else {
         is($plugin . ' ' . $ng->_cmdline, $EXPECTED{$infile}, $infile);
       }
     }
   }
 }
-
diff --git a/t/Nagios-Plugin-Getopt-04.t b/t/Monitoring-Plugin-Getopt-04.t
index 115f2a2..b6345d0 100644
--- a/t/Nagios-Plugin-Getopt-04.t
+++ b/t/Monitoring-Plugin-Getopt-04.t
@@ -1,29 +1,29 @@
-# Nagios::Plugin::Getopt spec-to-help generation tests
+# Monitoring::Plugin::Getopt spec-to-help generation tests
 
 use strict;
 
 use Test::More tests => 11;
-BEGIN { use_ok('Nagios::Plugin::Getopt') };
+BEGIN { use_ok('Monitoring::Plugin::Getopt') };
 
 # Needed to get evals to work in testing
-Nagios::Plugin::Functions::_use_die(1);
+Monitoring::Plugin::Functions::_use_die(1);
 
 my %PARAM = (
     version => '0.01',
     usage => "Don't use this plugin!",
 );
 
-sub setup 
+sub setup
 {
   # Instantiate object
-  my $ng = Nagios::Plugin::Getopt->new(%PARAM);
+  my $ng = Monitoring::Plugin::Getopt->new(%PARAM);
   ok($ng, 'constructor ok');
 
   # Positional args, no short arguments, INTEGER
   $ng->arg('warning=i' =>
     qq(Exit with WARNING status if less than INTEGER foobars are free),
     5);
-  
+
   # Named args, long + short arguments, INTEGER
   $ng->arg(
     spec => 'critical|c=i',
@@ -35,7 +35,7 @@ sub setup
   $ng->arg(
     spec => 'x|y|z=s',
     help => qq(Foobar. Default: %s),
-    default => "XYZ", 
+    default => "XYZ",
   );
 
   # Named args, multiple mixed, no label
@@ -95,4 +95,3 @@ like($@, qr/\n --avatar=AVATAR\n   Avatar\n/, 'avatar ok');
 like($@, qr/\n --disk=BYTES\n   Disk limit in BYTES\n --disk=PERCENT%\n   Disk limit in PERCENT\n --disk=STRING\n   Disk limit in FOOBARS \(Default: 1024\)\n/, 'disk multiline ok');
 like($@, qr/\n --limit=STRING\n   Limit in BYTES\n --limit=PERCENT%\n   Limit in PERCENT\n/, 'limit multiline ok');
 #print $@;
-
diff --git a/t/Monitoring-Plugin-Performance-02.t b/t/Monitoring-Plugin-Performance-02.t
new file mode 100644
index 0000000..c024685
--- /dev/null
+++ b/t/Monitoring-Plugin-Performance-02.t
@@ -0,0 +1,13 @@
+
+use strict;
+use Test::More tests => 3;
+use_ok("Monitoring::Plugin::Performance", use_die => 1);
+
+eval { Monitoring::Plugin::Functions::plugin_die("Testing") };
+is( $@, "MONITORING-PLUGIN-PERFORMANCE-02 UNKNOWN - Testing\n", "use_die correctly set on import");
+
+
+use_ok("Monitoring::Plugin::Performance");
+eval { Monitoring::Plugin::Functions::plugin_die("Test OK exit", 0) };
+
+fail("Should not get here if code works correctly because prior plugin_die should have exited");
diff --git a/t/Nagios-Plugin-Performance.t b/t/Monitoring-Plugin-Performance.t
index 8dce336..bedb2e2 100644
--- a/t/Nagios-Plugin-Performance.t
+++ b/t/Monitoring-Plugin-Performance.t
@@ -2,61 +2,61 @@
 use warnings;
 use strict;
 use Test::More;
-use Nagios::Plugin::Functions;
-Nagios::Plugin::Functions::_fake_exit(1);
+use Monitoring::Plugin::Functions;
+Monitoring::Plugin::Functions::_fake_exit(1);
 
 
 my (@p, $p);
 my @test = (
-  { 
+  {
     perfoutput => "/=382MB;15264;15269;0;32768", label => '/', rrdlabel => 'root', value => 382, uom => 'MB', warning => 15264, critical => 15269, min => 0, max => 32768, clean_label => "root",
   }, {
     perfoutput => "/var=218MB;9443;9448", label => '/var', rrdlabel => 'var', value => '218', uom => 'MB', warning => 9443, critical => 9448, min => undef, max => undef, clean_label => "var",
   }, {
     perfoutput => '/var/long@:-/filesystem/name/and/bad/chars=218MB;9443;9448', label => '/var/long@:-/filesystem/name/and/bad/chars', rrdlabel => 'var_long____filesys', value => '218', uom => 'MB', warning => 9443, critical => 9448, min => undef, max => undef, clean_label => 'var_long____filesystem_name_and_bad_chars',
   }, {
-    perfoutput => "'page file'=36%;80;90;", 
+    perfoutput => "'page file'=36%;80;90;",
     expected_perfoutput => "'page file'=36%;80;90",
     label => 'page file',
     rrdlabel => 'page_file',
-    value => '36', 
-    uom => '%', 
-    warning => 80, 
-    critical => 90, 
-    min => undef, 
-    max => undef, 
+    value => '36',
+    uom => '%',
+    warning => 80,
+    critical => 90,
+    min => undef,
+    max => undef,
     clean_label => 'page_file',
   }, {
-    perfoutput => "'data'=5;;;;", 
+    perfoutput => "'data'=5;;;;",
     expected_perfoutput => "data=5;;",
     label => 'data',
     rrdlabel => 'data',
     value => 5,
     uom => "",
-    warning => undef, 
-    critical => undef, 
-    min => undef, 
-    max => undef, 
+    warning => undef,
+    critical => undef,
+    min => undef,
+    max => undef,
     clean_label => 'data',
   },
 );
 
 plan tests => (11 * scalar @test) + 176;
 
-use_ok('Nagios::Plugin::Performance');
-diag "\nusing Nagios::Plugin::Performance revision ". $Nagios::Plugin::Performance::VERSION . "\n" if $ENV{TEST_VERBOSE};
+use_ok('Monitoring::Plugin::Performance');
+diag "\nusing Monitoring::Plugin::Performance revision ". $Monitoring::Plugin::Performance::VERSION . "\n" if $ENV{TEST_VERBOSE};
 
 # Round-trip tests
 for my $t (@test) {
     # Parse to components
-    ($p) = Nagios::Plugin::Performance->parse_perfstring($t->{perfoutput});
+    ($p) = Monitoring::Plugin::Performance->parse_perfstring($t->{perfoutput});
     is ($p->value, $t->{value}, "value okay $t->{value}");
     is ($p->label, $t->{label}, "label okay $t->{label}");
     is ($p->uom,   $t->{uom},   "uom okay $t->{uom}");
 
     # Construct from components
     my @construct = qw(label value uom warning critical min max);
-    $p = Nagios::Plugin::Performance->new(map { $_ => $t->{$_} } @construct);
+    $p = Monitoring::Plugin::Performance->new(map { $_ => $t->{$_} } @construct);
     my $expected_perfoutput = $t->{perfoutput};
     if (exists $t->{expected_perfoutput}) {
         $expected_perfoutput = $t->{expected_perfoutput};
@@ -75,9 +75,9 @@ for my $t (@test) {
 
     # Construct using threshold
     @construct = qw(label value uom min max);
-    $p = Nagios::Plugin::Performance->new(
-        map({ $_ => $t->{$_} } @construct), 
-        threshold => Nagios::Plugin::Threshold->set_thresholds(warning => $t->{warning}, critical => $t->{critical}),
+    $p = Monitoring::Plugin::Performance->new(
+        map({ $_ => $t->{$_} } @construct),
+        threshold => Monitoring::Plugin::Threshold->set_thresholds(warning => $t->{warning}, critical => $t->{critical}),
     );
     is($p->perfoutput, $expected_perfoutput, "perfoutput okay ($expected_perfoutput)");
     # Check warning/critical accessors
@@ -92,7 +92,7 @@ for my $t (@test) {
 
 
 # Test multiple parse_perfstrings
-@p = Nagios::Plugin::Performance->parse_perfstring("/=382MB;15264;15269;; /var=218MB;9443;9448");
+@p = Monitoring::Plugin::Performance->parse_perfstring("/=382MB;15264;15269;; /var=218MB;9443;9448");
 cmp_ok( $p[0]->label, 'eq', "/", "label okay");
 cmp_ok( $p[0]->rrdlabel, 'eq', "root", "rrd label okay");
 cmp_ok( $p[0]->value, '==', 382, "value okay");
@@ -109,14 +109,14 @@ cmp_ok( $p[1]->uom, 'eq', "MB", "uom okay");
 cmp_ok( $p[1]->threshold->warning->end, "==", 9443, "warn okay");
 cmp_ok( $p[1]->threshold->critical->end, "==", 9448, "crit okay");
 
-@p = Nagios::Plugin::Performance->parse_perfstring("rubbish");
+@p = Monitoring::Plugin::Performance->parse_perfstring("rubbish");
 ok( ! @p, "Errors correctly");
-ok( ! Nagios::Plugin::Performance->parse_perfstring(""), "Errors on empty string");
+ok( ! Monitoring::Plugin::Performance->parse_perfstring(""), "Errors on empty string");
 
 
 
 # Check 1 bad with 1 good format output
-@p = Nagios::Plugin::Performance->parse_perfstring("rta=&391ms;100,200;500,034;0;   pl=0%;20;60  ");
+@p = Monitoring::Plugin::Performance->parse_perfstring("rta=&391ms;100,200;500,034;0;   pl=0%;20;60  ");
 is( scalar @p, 1, "One bad piece of data - only one returned" );
 is( $p[0]->label, "pl", "label okay for different numeric");
 is( $p[0]->value, 0, "value okay");
@@ -127,7 +127,7 @@ is( $p[0]->threshold->critical->is_set, 1, "Critical range has been set");
 is( $p[0]->threshold->critical, "60", "warn okay");
 
 # Same as above, but order swapped
-@p = Nagios::Plugin::Performance->parse_perfstring("   pl=0%;20;60  rta=&391ms;100,200;500,034;0;   ");
+@p = Monitoring::Plugin::Performance->parse_perfstring("   pl=0%;20;60  rta=&391ms;100,200;500,034;0;   ");
 is( scalar @p, 1, "One bad piece of data - only one returned" );
 is( $p[0]->label, "pl", "label okay for different numeric");
 is( $p[0]->value, 0, "value okay");
@@ -140,7 +140,7 @@ is( $p[0]->threshold->critical, "60", "warn okay");
 
 
 
-@p = Nagios::Plugin::Performance->parse_perfstring(
+@p = Monitoring::Plugin::Performance->parse_perfstring(
         "time=0.001229s;0.000000;0.000000;0.000000;10.000000");
 cmp_ok( $p[0]->label, "eq", "time", "label okay");
 cmp_ok( $p[0]->value, "==", 0.001229, "value okay");
@@ -150,27 +150,27 @@ cmp_ok( $p[0]->uom,   "eq", "s", "uom okay");
 
 
 
-@p = Nagios::Plugin::Performance->parse_perfstring(
+@p = Monitoring::Plugin::Performance->parse_perfstring(
         "load1=0.000;5.000;9.000;0; load5=0.000;5.000;9.000;0; load15=0.000;5.000;9.000;0;");
 cmp_ok( $p[0]->label, "eq", "load1", "label okay");
-cmp_ok( $p[0]->value, "eq", "0", "value okay with 0 as string");        
+cmp_ok( $p[0]->value, "eq", "0", "value okay with 0 as string");
 cmp_ok( $p[0]->uom, "eq", "", "uom empty");
 cmp_ok( $p[0]->threshold->warning, "eq", "5", "warn okay");
 cmp_ok( $p[0]->threshold->critical, "eq", "9", "crit okay");
 cmp_ok( $p[1]->label, "eq", "load5", "label okay");
 cmp_ok( $p[2]->label, "eq", "load15", "label okay");
 
-@p = Nagios::Plugin::Performance->parse_perfstring( "users=4;20;50;0" );
+@p = Monitoring::Plugin::Performance->parse_perfstring( "users=4;20;50;0" );
 cmp_ok( $p[0]->label, "eq", "users", "label okay");
 cmp_ok( $p[0]->value, "==", 4, "value okay");
 cmp_ok( $p[0]->uom, "eq", "", "uom empty");
 cmp_ok( $p[0]->threshold->warning, 'eq', "20", "warn okay");
 cmp_ok( $p[0]->threshold->critical, 'eq', "50", "crit okay");
 
-@p = Nagios::Plugin::Performance->parse_perfstring( "users=4;20;50;0\n" );
+@p = Monitoring::Plugin::Performance->parse_perfstring( "users=4;20;50;0\n" );
     ok( @p, "parse correctly with linefeed at end (nagiosgraph)");
 
-@p = Nagios::Plugin::Performance->parse_perfstring( 
+@p = Monitoring::Plugin::Performance->parse_perfstring(
         "time=0.215300s;5.000000;10.000000;0.000000 size=426B;;;0" );
 cmp_ok( $p[0]->label, "eq", "time", "label okay");
 cmp_ok( $p[0]->value, "eq", "0.2153", "value okay");
@@ -184,21 +184,21 @@ cmp_ok( $p[1]->uom, "eq", "B", "uom okay");
     ok( ! $p[1]->threshold->critical->is_set, "crit okay");
 
 # Edge cases
-@p = Nagios::Plugin::Performance->parse_perfstring("/home/a-m=0;0;0 shared-folder:big=20 12345678901234567890=20");
+@p = Monitoring::Plugin::Performance->parse_perfstring("/home/a-m=0;0;0 shared-folder:big=20 12345678901234567890=20");
 cmp_ok( $p[0]->rrdlabel, "eq", "home_a_m", "changing / to _");
     ok( $p[0]->threshold->warning->is_set, "Warning range has been set");
 cmp_ok( $p[1]->rrdlabel, "eq", "shared_folder_big", "replacing bad characters");
 cmp_ok( $p[2]->rrdlabel, "eq", "1234567890123456789", "shortening rrd label");
 
-# turn off fake_exit and enable use_die so we pick up on errors via nagios_die
-Nagios::Plugin::Functions::_use_die(1);
-Nagios::Plugin::Functions::_fake_exit(0);
+# turn off fake_exit and enable use_die so we pick up on errors via plugin_die
+Monitoring::Plugin::Functions::_use_die(1);
+Monitoring::Plugin::Functions::_fake_exit(0);
 
-@p = Nagios::Plugin::Performance->parse_perfstring("time=0.002722s;0.000000;0.000000;0.000000;10.000000");
+@p = Monitoring::Plugin::Performance->parse_perfstring("time=0.002722s;0.000000;0.000000;0.000000;10.000000");
 cmp_ok( $p[0]->label, "eq", "time", "label okay");
 cmp_ok( $p[0]->value, "eq", "0.002722", "value okay");
 cmp_ok( $p[0]->uom, "eq", "s", "uom okay");
-    ok( defined $p[0]->threshold->warning->is_set, "Warning range has been set"); 
+    ok( defined $p[0]->threshold->warning->is_set, "Warning range has been set");
     ok( defined $p[0]->threshold->critical->is_set, "Critical range has been set");
 # The two below used to be cmp_ok, but Test::More 0.86 appears to have a problem with a stringification
 # of 0. See http://rt.cpan.org/Ticket/Display.html?id=41109
@@ -206,7 +206,7 @@ cmp_ok( $p[0]->uom, "eq", "s", "uom okay");
 is( $p[0]->threshold->warning."", "0", "warn okay");
 is( $p[0]->threshold->critical."", "0", "crit okay");
 
-@p = Nagios::Plugin::Performance->parse_perfstring("pct_used=73.7%;90;95");
+@p = Monitoring::Plugin::Performance->parse_perfstring("pct_used=73.7%;90;95");
 cmp_ok( $p[0]->label, "eq", "pct_used", "label okay");
 cmp_ok( $p[0]->value, "eq", "73.7", "value okay");
 cmp_ok( $p[0]->uom, "eq", "%", "uom okay");
@@ -216,7 +216,7 @@ cmp_ok( $p[0]->threshold->warning, 'eq', "90", "warn okay");
 cmp_ok( $p[0]->threshold->critical, 'eq', "95", "crit okay");
 
 # Check ranges are parsed correctly
-@p = Nagios::Plugin::Performance->parse_perfstring("availability=93.8%;90:99;");
+@p = Monitoring::Plugin::Performance->parse_perfstring("availability=93.8%;90:99;");
 is( $p[0]->label, "availability", "label okay");
 is( $p[0]->value, "93.8", "value okay");
 is( $p[0]->uom, "%", "uom okay");
@@ -225,7 +225,7 @@ is( $p[0]->threshold->critical->is_set, 0, "Critical range has not been set");
 is( $p[0]->threshold->warning, "90:99", "warn okay");
 
 # Check that negative values are parsed correctly in value and ranges
-@p = Nagios::Plugin::Performance->parse_perfstring("offset=-0.004476s;-60.000000:-5;-120.000000:-3;");
+@p = Monitoring::Plugin::Performance->parse_perfstring("offset=-0.004476s;-60.000000:-5;-120.000000:-3;");
 is( $p[0]->label, "offset", "label okay");
 is( $p[0]->value, "-0.004476", "value okay");
 is( $p[0]->uom, "s", "uom okay");
@@ -235,7 +235,7 @@ is( $p[0]->threshold->warning, "-60:-5", "warn okay");
 is( $p[0]->threshold->critical, "-120:-3", "crit okay");
 
 # Check infinity values are okay
-@p = Nagios::Plugin::Performance->parse_perfstring("salary=52GBP;~:23.5;45.2:");
+@p = Monitoring::Plugin::Performance->parse_perfstring("salary=52GBP;~:23.5;45.2:");
 is( $p[0]->label, "salary", "label okay");
 is( $p[0]->value, "52", "value okay");
 is( $p[0]->uom, "GBP", "uom okay");
@@ -245,7 +245,7 @@ is( $p[0]->threshold->warning, "~:23.5", "warn okay");
 is( $p[0]->threshold->critical, "45.2:", "warn okay");
 
 # Check scientific notation
-@p = Nagios::Plugin::Performance->parse_perfstring("offset=1.120567322e-05");
+@p = Monitoring::Plugin::Performance->parse_perfstring("offset=1.120567322e-05");
 is( $p[0]->label, "offset", "label okay for scientific notation");
 is( $p[0]->value, 1.120567322e-05, "value okay");
 is( $p[0]->uom, "", "uom okay");
@@ -254,7 +254,7 @@ ok( ! $p[0]->threshold->critical->is_set, "Critical range has not been set");
 
 
 # Check scientific notation with warnings and criticals
-@p = Nagios::Plugin::Performance->parse_perfstring("offset=-1.120567322e-05unit;-1.1e-05:1.0e-03;4.3e+02:4.3e+25");
+@p = Monitoring::Plugin::Performance->parse_perfstring("offset=-1.120567322e-05unit;-1.1e-05:1.0e-03;4.3e+02:4.3e+25");
 is( $p[0]->label, "offset", "label okay for scientific notation in warnings and criticals");
 is( $p[0]->value, -1.120567322e-05, "value okay");
 is( $p[0]->uom, "unit", "uom okay");
@@ -266,7 +266,7 @@ is( $p[0]->threshold->critical, "430:4.3e+25", "warn okay");
 
 
 # Check different collation with commas instead of periods
-@p = Nagios::Plugin::Performance->parse_perfstring("rta=1,391ms;100,200;500,034;0; pl=0%;20;60;;");
+@p = Monitoring::Plugin::Performance->parse_perfstring("rta=1,391ms;100,200;500,034;0; pl=0%;20;60;;");
 is( $p[0]->label, "rta", "label okay for numeric with commas instead of periods");
 is( $p[0]->value, 1.391, "value okay");
 is( $p[0]->uom, "ms", "uom okay");
@@ -284,7 +284,7 @@ is( $p[1]->threshold->critical, "60", "warn okay");
 
 
 # Another set of comma separated stuff
-@p = Nagios::Plugin::Performance->parse_perfstring("offset=-0,023545s;60,000000;120,000000;");
+@p = Monitoring::Plugin::Performance->parse_perfstring("offset=-0,023545s;60,000000;120,000000;");
 is( $p[0]->label, "offset", "label okay for numeric with commas instead of periods");
 is( $p[0]->value, -0.023545, "value okay");
 is( $p[0]->uom, "s", "uom okay");
@@ -294,14 +294,14 @@ is( $p[0]->threshold->critical->is_set, 1, "Critical range has been set");
 is( $p[0]->threshold->critical, 120, "warn okay");
 
 # Some values with funny commas
-@p = Nagios::Plugin::Performance->parse_perfstring("time=1800,600,300,0,3600 other=45.6");
+@p = Monitoring::Plugin::Performance->parse_perfstring("time=1800,600,300,0,3600 other=45.6");
 is( $p[0]->label, "other", "Ignored time=1800,600,300,0,3600, but allowed other=45.6");
 is( $p[0]->value, 45.6, "value okay");
 is( $p[0]->uom, "", "uom okay");
 
 
 # Test labels with spaces (returned by nsclient++)
-@p = Nagios::Plugin::Performance->parse_perfstring("'C:\ Label:  Serial Number bc22aa2e'=8015MB;16387;18435;0;20484 'D:\ Label: Serial Number XA22aa2e'=8015MB;16388;18436;1;2048");
+@p = Monitoring::Plugin::Performance->parse_perfstring("'C:\ Label:  Serial Number bc22aa2e'=8015MB;16387;18435;0;20484 'D:\ Label: Serial Number XA22aa2e'=8015MB;16388;18436;1;2048");
 is( $p[0]->label, "C:\ Label:  Serial Number bc22aa2e");
 is( $p[0]->rrdlabel, "C__Label___Serial_N");
 is( $p[0]->value, 8015, "value okay");
@@ -322,7 +322,7 @@ is( $p[1]->max, 2048, "max ok");
 
 
 # Mix labels with and without quotes
-@p = Nagios::Plugin::Performance->parse_perfstring("  short=4 'C:\ Label:  Serial Number bc22aa2e'=8015MB;16387;18435;0;20484 end=5 ");
+@p = Monitoring::Plugin::Performance->parse_perfstring("  short=4 'C:\ Label:  Serial Number bc22aa2e'=8015MB;16387;18435;0;20484 end=5 ");
 is( $p[0]->label, "short" );
 is( $p[0]->rrdlabel, "short");
 is( $p[0]->value, 4, "value okay");
@@ -351,7 +351,7 @@ is( $p[2]->min, undef, "min ok");
 is( $p[2]->max, undef, "max ok");
 
 
-@p = Nagios::Plugin::Performance->parse_perfstring("processes=9;WKFLSV32.exe;9=");
+@p = Monitoring::Plugin::Performance->parse_perfstring("processes=9;WKFLSV32.exe;9=");
 is_deeply( \@p, [], "Fails parsing correctly");
 
-# add_perfdata tests in t/Nagios-Plugin-01.t
+# add_perfdata tests in t/Monitoring-Plugin-01.t
diff --git a/t/Nagios-Plugin-Range.t b/t/Monitoring-Plugin-Range.t
index 6fe080c..9a6e826 100644
--- a/t/Nagios-Plugin-Range.t
+++ b/t/Monitoring-Plugin-Range.t
@@ -1,15 +1,15 @@
 
 use strict;
-#use Test::More qw(no_plan); 
+#use Test::More qw(no_plan);
 use Test::More tests => 151;
 
-BEGIN { 
-  use_ok('Nagios::Plugin::Range');
+BEGIN {
+  use_ok('Monitoring::Plugin::Range');
   # Silence warnings unless TEST_VERBOSE is set
   $SIG{__WARN__} = sub { warn $_[0] if $ENV{TEST_VERBOSE} };
 };
 
-diag "\nusing Nagios::Plugin::Range revision ". $Nagios::Plugin::Range::VERSION . "\n" if $ENV{TEST_VERBOSE};
+diag "\nusing Monitoring::Plugin::Range revision ". $Monitoring::Plugin::Range::VERSION . "\n" if $ENV{TEST_VERBOSE};
 
 my $r;
 
@@ -25,14 +25,14 @@ foreach (qw(
 
 ),  '1,10'  # avoid warning about using , inside qw()
 ) {
-    $r =Nagios::Plugin::Range->parse_range_string($_);
+    $r =Monitoring::Plugin::Range->parse_range_string($_);
     is $r, undef, "'$_' should not be a valid range" ;
 }
 
 
 diag "range: 0..6 inclusive" if $ENV{TEST_VERBOSE};
-$r = Nagios::Plugin::Range->parse_range_string("6");
-isa_ok( $r, "Nagios::Plugin::Range");
+$r = Monitoring::Plugin::Range->parse_range_string("6");
+isa_ok( $r, "Monitoring::Plugin::Range");
 ok( defined $r, "'6' is valid range");
 cmp_ok( $r->start, '==', 0, "Start correct");
 cmp_ok( $r->start_infinity, '==', 0, "Not using negative infinity");
@@ -53,7 +53,7 @@ sub test_expected {
     my $r = shift;
     my $expected = shift;
     foreach (sort {$a<=>$b} keys %$expected) {
-        is $r->check_range($_), $expected->{$_}, 
+        is $r->check_range($_), $expected->{$_},
         "    $_ should " . ($expected->{$_} ? 'not ' : '') . "be in the range (line ".(caller)[2].")";
     }
 }
@@ -61,7 +61,7 @@ sub test_expected {
 test_expected( $r, $expected );
 
 diag "range :  -7..23, inclusive" if $ENV{TEST_VERBOSE};
-$r = Nagios::Plugin::Range->parse_range_string("-7:23");
+$r = Monitoring::Plugin::Range->parse_range_string("-7:23");
 ok( defined $r, "'-7:23' is valid range");
 cmp_ok( $r->start,          '==', -7, "Start correct");
 cmp_ok( $r->start_infinity, '==', 0, "Not using negative infinity");
@@ -72,7 +72,7 @@ cmp_ok( $r,                 'eq', "-7:23", "Stringification back to original");
 $expected = {
     -23 => 1,
     -7 => 0,
-    -1 => 0, 
+    -1 => 0,
     0 => 0,
     4  => 0,
     23  => 0,
@@ -83,7 +83,7 @@ test_expected( $r, $expected );
 
 
 diag "range : 0..5.75, inclusive" if $ENV{TEST_VERBOSE};
-$r = Nagios::Plugin::Range->parse_range_string(":5.75");
+$r = Monitoring::Plugin::Range->parse_range_string(":5.75");
 ok( defined $r, "':5.75' is valid range");
 cmp_ok( $r->start,          '==', 0, "Start correct");
 cmp_ok( $r->start_infinity, '==', 0, "Not using negative infinity");
@@ -105,7 +105,7 @@ test_expected( $r, $expected );
 
 
 diag "range : negative infinity .. -95.99, inclusive" if $ENV{TEST_VERBOSE};
-$r = Nagios::Plugin::Range->parse_range_string("~:-95.99");
+$r = Monitoring::Plugin::Range->parse_range_string("~:-95.99");
 ok( defined $r, "'~:-95.99' is valid range");
 cmp_ok( $r->start_infinity, '==', 1, "Using negative infinity");
 cmp_ok( $r->end,            '==', -95.99, "End correct");
@@ -126,7 +126,7 @@ test_expected( $r, $expected );
 
 diag "range 10..infinity , inclusive" if $ENV{TEST_VERBOSE};
 test_expected( $r, $expected );
-$r = Nagios::Plugin::Range->parse_range_string("10:");
+$r = Monitoring::Plugin::Range->parse_range_string("10:");
 ok( defined $r, "'10:' is valid range");
 cmp_ok( $r->start,          '==', 10, "Start correct");
 cmp_ok( $r->start_infinity, '==', 0, "Not using negative infinity");
@@ -147,7 +147,7 @@ test_expected( $r, $expected );
 
 diag "range 123456789012345..infinity , inclusive" if $ENV{TEST_VERBOSE};
 test_expected( $r, $expected );
-$r = Nagios::Plugin::Range->parse_range_string("123456789012345:");
+$r = Monitoring::Plugin::Range->parse_range_string("123456789012345:");
 ok( defined $r, "'123456789012345:' is valid range");
 cmp_ok( $r->start,          '==', 123456789012345, "Start correct");
 cmp_ok( $r->start_infinity, '==', 0, "Not using negative infinity");
@@ -159,7 +159,7 @@ $expected = {
     0  => 1,
     # The fractional values needs to be quoted, otherwise the hash rounds it up to ..345
     # and there is one less test run.
-    # I think some newer versions of perl use a higher precision value for the hash key. 
+    # I think some newer versions of perl use a higher precision value for the hash key.
     # This doesn't appear to affect the actual plugin though
     "123456789012344.91" => 1,
     123456789012345  => 0,
@@ -170,7 +170,7 @@ test_expected( $r, $expected );
 
 
 diag "range:  <= zero " if $ENV{TEST_VERBOSE};
-$r = Nagios::Plugin::Range->parse_range_string("~:0");
+$r = Monitoring::Plugin::Range->parse_range_string("~:0");
 ok( defined $r, "'~:0' is valid range");
 cmp_ok( $r->start_infinity, '==', 1, "Using negative infinity");
 cmp_ok( $r->end,            '==', 0, "End correct");
@@ -191,7 +191,7 @@ test_expected( $r, $expected );
 
 
 diag "range: OUTSIDE 0..657.8210567" if $ENV{TEST_VERBOSE};
-$r = Nagios::Plugin::Range->parse_range_string('@0:657.8210567');
+$r = Monitoring::Plugin::Range->parse_range_string('@0:657.8210567');
 ok( defined $r, '"@0:657.8210567" is a valid range');
 cmp_ok( $r->start,          '==', 0, "Start correct");
 cmp_ok( $r->start_infinity, '==', 0, "Not using negative infinity");
@@ -216,7 +216,7 @@ test_expected( $r, $expected );
 
 
 diag "range: 1..1 inclusive (equals one)" if $ENV{TEST_VERBOSE};
-$r = Nagios::Plugin::Range->parse_range_string('1:1');
+$r = Monitoring::Plugin::Range->parse_range_string('1:1');
 ok( defined $r, '"1:1" is a valid range');
 cmp_ok( $r->start,          '==', 1, "Start correct");
 cmp_ok( $r->start_infinity, '==', 0, "Not using negative infinity");
@@ -237,7 +237,7 @@ $expected = {
 test_expected( $r, $expected );
 
 
-$r = Nagios::Plugin::Range->parse_range_string('2:1');
+$r = Monitoring::Plugin::Range->parse_range_string('2:1');
 ok( ! defined $r, '"2:1" is rejected');
 
 # TODO: Need more tests for invalid data
diff --git a/t/Nagios-Plugin-Threshold.t b/t/Monitoring-Plugin-Threshold.t
index 78d2189..8849464 100644
--- a/t/Nagios-Plugin-Threshold.t
+++ b/t/Monitoring-Plugin-Threshold.t
@@ -1,32 +1,32 @@
 
 use strict;
 use Test::More tests => 93;
-BEGIN { 
-  use_ok('Nagios::Plugin::Threshold'); 
-  use_ok('Nagios::Plugin::Functions', ':all' );
+BEGIN {
+  use_ok('Monitoring::Plugin::Threshold');
+  use_ok('Monitoring::Plugin::Functions', ':all' );
   # Silence warnings unless TEST_VERBOSE is set
   $SIG{__WARN__} = sub { warn $_[0] if $ENV{TEST_VERBOSE} };
 }
 
-diag "\nusing Nagios::Plugin::Threshold revision ". $Nagios::Plugin::Threshold::VERSION . "\n"
+diag "\nusing Monitoring::Plugin::Threshold revision ". $Monitoring::Plugin::Threshold::VERSION . "\n"
   if $ENV{TEST_VERBOSE};
 
-Nagios::Plugin::Functions::_fake_exit(1);
+Monitoring::Plugin::Functions::_fake_exit(1);
 
 my $t;
 
-$t = Nagios::Plugin::Threshold->set_thresholds(warning => undef, critical => undef);
+$t = Monitoring::Plugin::Threshold->set_thresholds(warning => undef, critical => undef);
 ok( defined $t, "two undefs" );
 ok( ! $t->warning->is_set, "warning not set" );
 ok( ! $t->critical->is_set, "critical not set" );
 
-$t = Nagios::Plugin::Threshold->set_thresholds(warning => "", critical => "");
+$t = Monitoring::Plugin::Threshold->set_thresholds(warning => "", critical => "");
 ok( defined $t, "two empty strings" );
 ok( ! $t->warning->is_set, "warning not set" );
 ok( ! $t->critical->is_set, "critical not set" );
 
 diag "threshold: critical if > 80" if $ENV{TEST_VERBOSE};
-my $t = Nagios::Plugin::Threshold->set_thresholds(critical => "80");
+my $t = Monitoring::Plugin::Threshold->set_thresholds(critical => "80");
 ok( defined $t, "Threshold ('', '80') set");
 ok( ! $t->warning->is_set, "Warning not set");
 cmp_ok( $t->critical->start, '==', 0, "Critical strat set correctly");
@@ -59,11 +59,11 @@ sub test_expected_statuses {
 }
 test_expected_statuses( $t, $expected );
 
-# GMC: this test seems bogus to me - either we've died, in which case internal 
+# GMC: this test seems bogus to me - either we've died, in which case internal
 # state is undefined (and untestable!), or we should be returning a non-fatal error
 if (0) {
   diag "threshold: warn if less than 5 or more than 33." if $ENV{TEST_VERBOSE};
-  eval { $t = Nagios::Plugin::Threshold->set_thresholds(warning => "5:33", critical => "") };
+  eval { $t = Monitoring::Plugin::Threshold->set_thresholds(warning => "5:33", critical => "") };
   ok( defined $t, "Threshold ('5:33', '') set");
   cmp_ok( $t->warning->start, '==', 5, "Warning start set");
   cmp_ok( $t->warning->end, '==',   33, "Warning end set");
@@ -72,7 +72,7 @@ if (0) {
 
 # GC: same as previous test, except critical is undef instead of ''
 diag "threshold: warn if less than 5 or more than 33." if $ENV{TEST_VERBOSE};
-$t = Nagios::Plugin::Threshold->set_thresholds(warning => "5:33", critical => undef);
+$t = Monitoring::Plugin::Threshold->set_thresholds(warning => "5:33", critical => undef);
 ok( defined $t, "Threshold ('5:33', '') set");
 cmp_ok( $t->warning->start, '==', 5, "Warning start set");
 cmp_ok( $t->warning->end, '==',   33, "Warning end set");
@@ -91,7 +91,7 @@ $expected = { qw(
 test_expected_statuses( $t, $expected );
 
 diag "threshold: warn if more than 30; critical if > 60" if $ENV{TEST_VERBOSE};
-$t = Nagios::Plugin::Threshold->set_thresholds(warning => "~:30", critical => "~:60");
+$t = Monitoring::Plugin::Threshold->set_thresholds(warning => "~:30", critical => "~:60");
 ok( defined $t, "Threshold ('~:30', '~:60') set");
 cmp_ok( $t->warning->end, '==', 30, "Warning end set");
 cmp_ok( $t->critical->end, '==',60, "Critical end set");
@@ -118,23 +118,23 @@ test_expected_statuses( $t, $expected );
 goto SKIP_DEATH;
 diag "threshold: test pure crap for arguments - default to OK." if $ENV{TEST_VERBOSE};
 diag "you should see one invalid range definition warning and an UNKNOWN line here:\n";
-Nagios::Plugin::Functions->print_on_die(1);
-Nagios::Plugin::Functions->exit_on_die(1);
+Monitoring::Plugin::Functions->print_on_die(1);
+Monitoring::Plugin::Functions->exit_on_die(1);
 
 dies_ok( sub {
-        $t = Nagios::Plugin::Threshold->set_thresholds(
-                                                                                                   warning => "total", 
+        $t = Monitoring::Plugin::Threshold->set_thresholds(
+                                                                                                   warning => "total",
                                                                                                    critical => "rubbish"
                                                                                                    )
-        }, "bad thresholds cause death" 
+        }, "bad thresholds cause death"
 );
-Nagios::Plugin::Functions->print_on_die(0);
-Nagios::Plugin::Functions->exit_on_die(0);
+Monitoring::Plugin::Functions->print_on_die(0);
+Monitoring::Plugin::Functions->exit_on_die(0);
 SKIP_DEATH:
 
 
 diag "threshold: critical if > 25 " if $ENV{TEST_VERBOSE};
-$t = Nagios::Plugin::Threshold->set_thresholds( critical => "~:25" );
+$t = Monitoring::Plugin::Threshold->set_thresholds( critical => "~:25" );
 ok( defined $t, "Threshold ('', '~:25') set (".$t->critical.")" );
 ok( ! $t->warning->is_set, "Warning not set");
 cmp_ok( $t->critical->end, '==',25, "Critical end set");
@@ -145,14 +145,14 @@ $expected = { qw(
     4               OK
     10              OK
     14.21           OK
-    25              OK  
+    25              OK
     25.01           CRITICAL
     31001           CRITICAL
 ) };
 test_expected_statuses( $t, $expected);
 
 diag "threshold: warn if OUTSIDE {10..25} , critical if > 25 " if $ENV{TEST_VERBOSE};
-$t = Nagios::Plugin::Threshold->set_thresholds(warning => "10:25", critical => "~:25");
+$t = Monitoring::Plugin::Threshold->set_thresholds(warning => "10:25", critical => "~:25");
 ok( defined $t, "Threshold ('10:25', '~:25') set");
 cmp_ok( $t->warning->start, '==', 10, "Warning start set");
 cmp_ok( $t->warning->end, '==',   25, "Warning end set");
@@ -164,7 +164,7 @@ $expected = { qw(
     9.999999        WARNING
     10              OK
     14.21           OK
-    25              OK  
+    25              OK
     25.01           CRITICAL
     31001           CRITICAL
 ) };
@@ -172,7 +172,7 @@ test_expected_statuses( $t, $expected );
 
 
 diag "warn if INSIDE {10..25} , critical if < 10 "  if $ENV{TEST_VERBOSE};
-$t = Nagios::Plugin::Threshold->set_thresholds(warning => "\@10:25", critical => "10:");
+$t = Monitoring::Plugin::Threshold->set_thresholds(warning => "\@10:25", critical => "10:");
 $expected = { qw(
     -1              CRITICAL
     4               CRITICAL
@@ -187,7 +187,7 @@ test_expected_statuses( $t, $expected );
 
 
 # GMC: as of 0.16, set_thresholds can also be called as a mutator
-diag "threshold mutator: warn if more than 30; critical if > 60" 
+diag "threshold mutator: warn if more than 30; critical if > 60"
   if $ENV{TEST_VERBOSE};
 my $t1 = $t;
 $t->set_thresholds(warning => "0:45", critical => "0:90");
@@ -200,16 +200,16 @@ is( $t->critical->end,  90, "Critical end ok");
 
 
 # Also as of 0.16, accepts N::P::Range objects as arguments
-my $warning  = Nagios::Plugin::Range->parse_range_string("50");
-my $critical = Nagios::Plugin::Range->parse_range_string("70:90");
-$t = Nagios::Plugin::Threshold->set_thresholds(warning => $warning, critical => $critical);
+my $warning  = Monitoring::Plugin::Range->parse_range_string("50");
+my $critical = Monitoring::Plugin::Range->parse_range_string("70:90");
+$t = Monitoring::Plugin::Threshold->set_thresholds(warning => $warning, critical => $critical);
 ok( defined $t, "Threshold from ranges ('50', '70:90') set");
 is( $t->warning->start,   0, "Warning start ok");
 is( $t->warning->end,    50, "Warning end ok");
 is( $t->critical->start, 70, "Critical start ok");
 is( $t->critical->end,   90, "Critical end ok");
 
-$critical = Nagios::Plugin::Range->parse_range_string("90:");
+$critical = Monitoring::Plugin::Range->parse_range_string("90:");
 $t->set_thresholds(warning => "~:20", critical => $critical);
 ok( defined $t, "Threshold from string + range ('~:20', '90:') set");
 ok( $t->warning->start_infinity, "Warning start ok (infinity)");
diff --git a/t/Nagios-Plugin-02.t b/t/Nagios-Plugin-02.t
deleted file mode 100644
index f64fb6f..0000000
--- a/t/Nagios-Plugin-02.t
+++ /dev/null
@@ -1,161 +0,0 @@
-# Nagios::Plugin test set 2, testing NP::Functions wrapping
-
-use strict;
-use Test::More tests => 103;
-
-BEGIN { use_ok("Nagios::Plugin") }
-require Nagios::Plugin::Functions;
-Nagios::Plugin::Functions::_fake_exit(1);
-
-# Hardcoded checks of constants
-my %ERRORS = %Nagios::Plugin::Functions::ERRORS;
-is(OK,          $ERRORS{OK},            "OK        => $ERRORS{OK}");
-is(WARNING,     $ERRORS{WARNING},       "WARNING   => $ERRORS{WARNING}");
-is(CRITICAL,    $ERRORS{CRITICAL},      "CRITICAL  => $ERRORS{CRITICAL}");
-is(UNKNOWN,     $ERRORS{UNKNOWN},       "UNKNOWN   => $ERRORS{UNKNOWN}");
-is(DEPENDENT,   $ERRORS{DEPENDENT},     "DEPENDENT => $ERRORS{DEPENDENT}");
-
-my $plugin = 'TEST_PLUGIN';
-my $np = Nagios::Plugin->new( shortname => $plugin );
-is($np->shortname, $plugin, "shortname() is $plugin"); 
-
-# Test nagios_exit( CONSTANT, $msg ), nagios_exit( $string, $msg )
-my $r;
-my @ok = (
-    [ OK,        "OK",           'test the first',  ],
-    [ WARNING,   "WARNING",      'test the second', ],
-    [ CRITICAL,  "CRITICAL",     'test the third',  ],
-    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
-    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
-);
-for (@ok) {
-    # CONSTANT
-    $r = $np->nagios_exit($_->[0], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_exit(%s, $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$plugin\b.*$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_exit(%s, $msg) output matched "%s"', $_->[1], 
-            $plugin . ' ' . $_->[1] . '.*' . $_->[2]));
-
-    # $string
-    $r = $np->nagios_exit($_->[1], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_exit("%s", $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$plugin\b.*$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_exit("%s", $msg) output matched "%s"', $_->[1], 
-            $plugin . ' ' . $_->[1] . '.*' . $_->[2]));
-    like($r, qr/$plugin\b.*$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_exit("%s", $msg) stringified matched "%s"', $_->[1], 
-            $plugin . ' ' . $_->[1] . '.*' . $_->[2]));
-}
-
-# nagios_exit code corner cases
-my @ugly1 = (
-    [ -1, 'testing code -1' ],
-    [ 7, 'testing code 7' ],
-    [ undef, 'testing code undef' ],
-    [ '', qq(testing code '') ],
-    [ 'string', qq(testing code 'string') ],
-);
-for (@ugly1) {
-    $r = $np->nagios_exit($_->[0], $_->[1]);
-    my $display = defined $_->[0] ? "'$_->[0]'" : 'undef';
-    is($r->return_code, UNKNOWN, "nagios_exit($display, \$msg) returned ". UNKNOWN);
-    like($r->message, qr/UNKNOWN\b.*\b$_->[1]$/, 
-        sprintf('nagios_exit(%s, $msg) output matched "%s"',
-            $display, 'UNKNOWN.*' . $_->[1]));
-}
-
-# nagios_exit message corner cases
-my @ugly2 = (
-    [ '' ],
-    [ undef ],
-    [ UNKNOWN ],
-);
-for (@ugly2) {
-    $r = $np->nagios_exit(CRITICAL, $_->[0]);
-    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
-    my $display2 = defined $_->[0] ? $_->[0] : '';
-    like($r->message, qr/CRITICAL\b.*\b$display2$/, 
-        sprintf('nagios_exit(%s, $msg) output matched "%s"',
-            $display1, "CRITICAL.*$display2"));
-}
-
-# Test nagios_die( $msg )
-my @msg = (
-    [ 'die you dog' ],
-    [ '' ],
-    [ undef ],
-);
-for (@msg) {
-    $r = $np->nagios_die($_->[0]);
-    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
-    my $display2 = defined $_->[0] ? $_->[0] : '';
-    is($r->return_code, UNKNOWN,
-        sprintf('nagios_die(%s) returned UNKNOWN', $display1));
-    like($r->message, qr/UNKNOWN\b.*\b$display2$/, 
-        sprintf('nagios_die(%s) output matched "%s"', $display1,
-            "UNKNOWN.*$display2"));
-}
-
-# Test nagios_die( CONSTANT, $msg ), nagios_die( $msg, CONSTANT ), 
-#   nagios_die( $string, $msg ), and nagios_die( $msg, $string )
-@ok = (
-    [ OK,        "OK",           'test the first',  ],
-    [ WARNING,   "WARNING",      'test the second', ],
-    [ CRITICAL,  "CRITICAL",     'test the third',  ],
-    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
-    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
-);
-for (@ok) {
-    # CONSTANT, $msg
-    $r = $np->nagios_die($_->[0], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die(%s, $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die(%s, $msg) output matched "%s"', 
-            $_->[1], $_->[1] . '.*' . $_->[2]));
-
-    # $msg, CONSTANT
-    $r = $np->nagios_die($_->[2], $_->[0]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die($msg, %s) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die($msg, %s) output matched "%s"', 
-            $_->[1], $_->[1] . '.*' . $_->[2]));
-
-    # $string, $msg
-    $r = $np->nagios_die($_->[1], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die("%s", $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die("%s", $msg) output matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-    like($r, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die("%s", $msg) stringified matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-
-    # $string, $msg
-    $r = $np->nagios_die($_->[2], $_->[1]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die($msg, "%s") returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die($msg, "%s") output matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-    like($r, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die($msg, "%s") stringified matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-}
-
-
-# shortname testing
-SKIP: {
-    skip "requires File::Basename", 2 unless eval { require File::Basename };
-    $np = Nagios::Plugin->new( version => "1");
-    $plugin = uc File::Basename::basename($0);
-    $plugin =~ s/\..*$//;
-    is($np->shortname, $plugin, "shortname() is '$plugin'");
-    $r = $np->nagios_exit(OK, "foobar");
-    like($r->message, qr/^$plugin OK/, "message begins with '$plugin OK'");
-}
-
diff --git a/t/Nagios-Plugin-Functions-01.t b/t/Nagios-Plugin-Functions-01.t
deleted file mode 100644
index 5268255..0000000
--- a/t/Nagios-Plugin-Functions-01.t
+++ /dev/null
@@ -1,161 +0,0 @@
-
-use strict;
-use Test::More tests => 113;
-
-BEGIN { use_ok("Nagios::Plugin::Functions", ":all"); }
-Nagios::Plugin::Functions::_fake_exit(1);
-
-my $this_version=$Nagios::Plugin::Functions::VERSION;
-foreach my $m ("", qw(::Threshold ::Getopt ::Performance ::Range)) {
-        my $mod = "Nagios::Plugin$m";
-        use_ok($mod);
-        # Lots of hackery below. Easier to say $mod->VERSION, but this is probably a recent perl thing
-        my $v = "$mod"."::VERSION";
-        my $a = eval "\$$v";
-        is($a, $this_version, "Version number for $mod the same as Functions: $this_version");
-}
-
-# check get_shortname
-is(get_shortname, "NAGIOS-PLUGIN-FUNCTIONS-01", "get_shortname ok");
-
-# Hardcoded checks of constants
-ok(defined %ERRORS, '%ERRORS defined');
-is(OK,          $ERRORS{OK},            "OK        => $ERRORS{OK}");
-is(WARNING,     $ERRORS{WARNING},       "WARNING   => $ERRORS{WARNING}");
-is(CRITICAL,    $ERRORS{CRITICAL},      "CRITICAL  => $ERRORS{CRITICAL}");
-is(UNKNOWN,     $ERRORS{UNKNOWN},       "UNKNOWN   => $ERRORS{UNKNOWN}");
-is(DEPENDENT,   $ERRORS{DEPENDENT},     "DEPENDENT => $ERRORS{DEPENDENT}");
-
-# Test nagios_exit( CONSTANT, $msg ), nagios_exit( $string, $msg )
-my $r;
-my @ok = (
-    [ OK,        "OK",           'test the first',  ],
-    [ WARNING,   "WARNING",      'test the second', ],
-    [ CRITICAL,  "CRITICAL",     'test the third',  ],
-    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
-    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
-);
-for (@ok) {
-    # CONSTANT
-    $r = nagios_exit($_->[0], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_exit(%s, $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_exit(%s, $msg) output matched "%s"', 
-            $_->[1], $_->[1] . '.*' . $_->[2]));
-
-    # $string
-    $r = nagios_exit($_->[1], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_exit("%s", $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_exit("%s", $msg) output matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-    like($r, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_exit("%s", $msg) stringified matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-}
-
-# nagios_exit code corner cases
-my @ugly1 = (
-    [ -1, 'testing code -1' ],
-    [ 7, 'testing code 7' ],
-    [ undef, 'testing code undef' ],
-    [ '', qq(testing code '') ],
-    [ 'string', qq(testing code 'string') ],
-);
-for (@ugly1) {
-    $r = nagios_exit($_->[0], $_->[1]);
-    my $display = defined $_->[0] ? "'$_->[0]'" : 'undef';
-    is($r->return_code, UNKNOWN, "nagios_exit($display, \$msg) returned ". UNKNOWN);
-    like($r->message, qr/UNKNOWN\b.*\b$_->[1]$/, 
-        sprintf('nagios_exit(%s, $msg) output matched "%s"',
-            $display, 'UNKNOWN.*' . $_->[1]));
-}
-
-# nagios_exit message corner cases
-my @ugly2 = (
-    [ '' ],
-    [ undef ],
-    [ UNKNOWN ],
-);
-for (@ugly2) {
-    $r = nagios_exit(CRITICAL, $_->[0]);
-    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
-    my $display2 = defined $_->[0] ? $_->[0] : '';
-    like($r->message, qr/CRITICAL\b.*\b$display2$/, 
-        sprintf('nagios_exit(%s, $msg) output matched "%s"',
-            $display1, "CRITICAL.*$display2"));
-}
-
-# Test nagios_die( $msg )
-my @msg = (
-    [ 'die you dog' ],
-    [ '' ],
-    [ undef ],
-);
-for (@msg) {
-    $r = nagios_die($_->[0]);
-    my $display1 = defined $_->[0] ? "'$_->[0]'" : "undef";
-    my $display2 = defined $_->[0] ? $_->[0] : '';
-    is($r->return_code, UNKNOWN,
-        sprintf('nagios_die(%s) returned UNKNOWN', $display1));
-    like($r->message, qr/UNKNOWN\b.*\b$display2$/, 
-        sprintf('nagios_die(%s) output matched "%s"', $display1,
-            "UNKNOWN.*$display2"));
-}
-
-# Test nagios_die( CONSTANT, $msg ), nagios_die( $msg, CONSTANT ), 
-#   nagios_die( $string, $msg ), and nagios_die( $msg, $string )
-@ok = (
-    [ OK,        "OK",           'test the first',  ],
-    [ WARNING,   "WARNING",      'test the second', ],
-    [ CRITICAL,  "CRITICAL",     'test the third',  ],
-    [ UNKNOWN,   "UNKNOWN",      'test the fourth', ],
-    [ DEPENDENT, "DEPENDENT",    'test the fifth',  ],
-);
-for (@ok) {
-    # CONSTANT, $msg
-    $r = nagios_die($_->[0], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die(%s, $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die(%s, $msg) output matched "%s"', 
-            $_->[1], $_->[1] . '.*' . $_->[2]));
-
-    # $msg, CONSTANT
-    $r = nagios_die($_->[2], $_->[0]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die($msg, %s) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die($msg, %s) output matched "%s"', 
-            $_->[1], $_->[1] . '.*' . $_->[2]));
-
-    # $string, $msg
-    $r = nagios_die($_->[1], $_->[2]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die("%s", $msg) returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die("%s", $msg) output matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-    like($r, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die("%s", $msg) stringified matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-
-    # $string, $msg
-    $r = nagios_die($_->[2], $_->[1]);
-    is($r->return_code, $_->[0], 
-        sprintf('nagios_die($msg, "%s") returned %s', $_->[1], $_->[0]));
-    like($r->message, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die($msg, "%s") output matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-    like($r, qr/$_->[1]\b.*\b$_->[2]$/, 
-        sprintf('nagios_die($msg, "%s") stringified matched "%s"', $_->[1], 
-            $_->[1] . '.*' . $_->[2]));
-}
-
-# Check that _use_die set to 1 will catch exceptions correctly
-Nagios::Plugin::Functions::_fake_exit(0);
-Nagios::Plugin::Functions::_use_die(1);
-eval { nagios_die("Using die") };
-is( $@, "NAGIOS-PLUGIN-FUNCTIONS-01 UNKNOWN - Using die\n", "Caught exception");
diff --git a/t/Nagios-Plugin-Performance-02.t b/t/Nagios-Plugin-Performance-02.t
deleted file mode 100644
index c0c5a71..0000000
--- a/t/Nagios-Plugin-Performance-02.t
+++ /dev/null
@@ -1,13 +0,0 @@
-
-use strict;
-use Test::More tests => 3;
-use_ok("Nagios::Plugin::Performance", use_die => 1);
-
-eval { Nagios::Plugin::Functions::nagios_die("Testing") };
-is( $@, "NAGIOS-PLUGIN-PERFORMANCE-02 UNKNOWN - Testing\n", "use_die correctly set on import");
-
-
-use_ok("Nagios::Plugin::Performance");
-eval { Nagios::Plugin::Functions::nagios_die("Test OK exit", 0) };
-
-fail("Should not get here if code works correctly because prior nagios_die should have exited");
diff --git a/t/check_stuff.pl b/t/check_stuff.pl
index 112a18a..4fc125c 100755
--- a/t/check_stuff.pl
+++ b/t/check_stuff.pl
@@ -2,21 +2,21 @@
 
 ###  check_stuff.pl
 
-# an example Nagios plugin using the Nagios::Plugin modules.  
+# an example Monitoring plugin using the Monitoring::Plugin modules.
 
 # Originally by Nathan Vonnahme, n8v at users dot sourceforge
 # dot net, July 19 2006
 
 # Please modify to your heart's content and use as the basis for all
-# the really cool Nagios monitoring scripts you're going to create.
-# You rock.  
+# the really cool monitoring scripts you're going to create.
+# You rock.
 
 ##############################################################################
 # prologue
 use strict;
 use warnings;
 
-use Nagios::Plugin ;
+use Monitoring::Plugin;
 
 use vars qw($VERSION $PROGNAME  $verbose $warn $critical $timeout $result);
 $VERSION = '1.0';
@@ -28,18 +28,18 @@ $PROGNAME = basename($0);
 
 ##############################################################################
 # define and get the command line options.
-#   see the command line option guidelines at 
-#   http://nagiosplug.sourceforge.net/developer-guidelines.html#PLUGOPTIONS
+#   see the command line option guidelines at
+#   https://www.monitoring-plugins.org/doc/guidelines.html#PLUGOPTIONS
 
 
-# Instantiate Nagios::Plugin object (the 'usage' parameter is mandatory)
-my $p = Nagios::Plugin->new(
+# Instantiate Monitoring::Plugin object (the 'usage' parameter is mandatory)
+my $p = Monitoring::Plugin->new(
     usage => "Usage: %s [ -v|--verbose ]  [-H <host>] [-t <timeout>]
-    [ -c|--critical=<critical threshold> ] 
-    [ -w|--warning=<warning threshold> ]  
+    [ -c|--critical=<critical threshold> ]
+    [ -w|--warning=<warning threshold> ]
     [ -r|--result = <INTEGER> ]",
     version => $VERSION,
-    blurb => 'This plugin is an example of a Nagios plugin written in Perl using the Nagios::Plugin modules.  It will generate a random integer between 1 and 20 (though you can specify the number with the -n option for testing), and will output OK, WARNING or CRITICAL if the resulting number is outside the specified thresholds.', 
+    blurb => 'This plugin is an example of a monitoring plugin written in Perl using the Monitoring::Plugin modules.  It will generate a random integer between 1 and 20 (though you can specify the number with the -n option for testing), and will output OK, WARNING or CRITICAL if the resulting number is outside the specified thresholds.',
 
         extra => "
 
@@ -47,11 +47,7 @@ THRESHOLDs for -w and -c are specified 'min:max' or 'min:' or ':max'
 (or 'max'). If specified '\@min:max', a warning status will be generated
 if the count *is* inside the specified range.
 
-See more threshold examples at http
-  : // nagiosplug
-  . sourceforge
-  . net / developer-guidelines
-  . html    #THRESHOLDFORMAT
+See more threshold examples at https://www.monitoring-plugins.org/doc/guidelines.html#THRESHOLDFORMAT
 
   Examples:
 
@@ -75,7 +71,7 @@ See more threshold examples at http
 $p->add_arg(
         spec => 'warning|w=s',
 
-        help => 
+        help =>
 qq{-w, --warning=INTEGER:INTEGER
    Minimum and maximum number of allowable result, outside of which a
    warning will be generated.  If omitted, no warning is generated.},
@@ -86,7 +82,7 @@ qq{-w, --warning=INTEGER:INTEGER
 
 $p->add_arg(
         spec => 'critical|c=s',
-        help => 
+        help =>
 qq{-c, --critical=INTEGER:INTEGER
    Minimum and maximum number of the generated result, outside of
    which a critical will be generated. },
@@ -94,7 +90,7 @@ qq{-c, --critical=INTEGER:INTEGER
 
 $p->add_arg(
         spec => 'result|r=f',
-        help => 
+        help =>
 qq{-r, --result=INTEGER
    Specify the result on the command line rather than generating a
    random number.  For testing.},
@@ -106,11 +102,11 @@ $p->getopts;
 
 # perform sanity checking on command line options
 if ( (defined $p->opts->result) && ($p->opts->result < 0 || $p->opts->result > 20) )  {
-    $p->nagios_die( " invalid number supplied for the -r option " );
+    $p->plugin_die( " invalid number supplied for the -r option " );
 }
 
 unless ( defined $p->opts->warning || defined $p->opts->critical ) {
-        $p->nagios_die( " you didn't supply a threshold argument " );
+        $p->plugin_die( " you didn't supply a threshold argument " );
 }
 
 
@@ -135,8 +131,7 @@ else {
 ##############################################################################
 # check the result against the defined warning and critical thresholds,
 # output the result and exit
-$p->nagios_exit( 
-         return_code => $p->check_threshold($result), 
-         message => " sample result was $result" 
+$p->plugin_exit(
+         return_code => $p->check_threshold($result),
+         message => " sample result was $result"
 );
-
diff --git a/t/check_stuff.t b/t/check_stuff.t
index 2815b76..6a1d845 100755
--- a/t/check_stuff.t
+++ b/t/check_stuff.t
@@ -1,5 +1,5 @@
 #!/usr/local/bin/perl
-# 
+#
 use strict; use warnings;
 #use Test::More qw(no_plan);
 use Test::More tests => 14;
@@ -10,7 +10,7 @@ $s = "$^X -Ilib $s";
 
 my $n = 'STUFF';
 
-# Nagios status strings and exit codes
+# Monitoring status strings and exit codes
 my %e  = qw(
                          OK           0
                          WARNING      1
@@ -58,9 +58,3 @@ sub test_expected {
                 like    $r,             qr/^$n $expected->{$_}/i,       "looks $expected->{$_} with $_";
         }
 }
-
-
-
-
-
-
diff --git a/t/npg03/README b/t/npg03/README
index 3dbdaf8..541ece7 100644
--- a/t/npg03/README
+++ b/t/npg03/README
@@ -1,15 +1,15 @@
-Nagios-Plugin-Getopt-03.t automatically tests all cases defined in 
-the 'input' directory and expects the output to match the 
-corresponding file in the 'expected' directory. To define a new test 
-case, just create a new file in the 'input' directory containing the 
-input command line, and a corresponding file in the 'expected' 
-directory containing what you think the expanded command line should 
+Monitoring-Plugin-Getopt-03.t automatically tests all cases defined in
+the 'input' directory and expects the output to match the
+corresponding file in the 'expected' directory. To define a new test
+case, just create a new file in the 'input' directory containing the
+input command line, and a corresponding file in the 'expected'
+directory containing what you think the expanded command line should
 be. Note that this expansion is normalised as follows:
 
 - command line arguments are reported in alphabetical order
 - extraneous white space is removed
 
-Also, if you use a completely new argument than those currently 
-defined in Nagios-Plugin-Getopt-03.t you will need to define it 
+Also, if you use a completely new argument than those currently
+defined in Monitoring-Plugin-Getopt-03.t you will need to define it
 there as well.