use strict;
use warnings;
use Cwd;
use Getopt::Long;

my ($help) = 0;
my ($num) = 20;  # Number of loops to run
my ($testdir) = "";
my ($verbose) = 0;

GetOptions('help|?'    => \$help,
           "num=i"     => \$num,
           "testdir=s" => \$testdir,
           'verbose'   => \$verbose) or &usage();

&usage() if $help;

# Header
print "Beginning Directory Manipulation Testing...\n" if $verbose;
$| = 1;

# Get the current working directory
my $home_dir = getcwd;

# Change to the test directory
chdir($testdir) or die "Can't make $testdir: $!\n";

# Set up test dirs if they do not exist
if (!-d "test")
{
    mkdir("test") or die "Can't make $testdir\\test: $!\n";
}
if (!-d "test1")
{
    mkdir("test1") or die "Can't make $testdir\\test1: $!\n";
}

# Change to the test area
chdir("test") or die "Can't change to test directory: $!\n";

# Directory Manipulation
for (my $dir = 0; $dir < $num; $dir++)
{
    # Make the directory
    if (!-d "directory$dir" ) {
        mkdir("directory$dir", 0755) or die "Can't make $testdir\\test
+\\directory$dir: $!\n";
    }

    # Change permissions of the directory
    if ($^O =~ /Win32/)
    {
        print "\nRunning chmod from - $home_dir\\..\\..\\bin\\chmod on
+ $testdir\\test\\directory$dir.\n" if ($verbose);
        if ($verbose)
        {
            system($home_dir . "\\..\\..\\bin\\chmod -v a+rwx $testdir
+\\test\\directory$dir");
        }
        else
        {
            system($home_dir . "\\..\\..\\bin\\chmod a+rwx $testdir\\t
+est\\directory$dir");
        }
    }
    else
    {
        system("/bin/chmod 777 directory$dir");
          or warn "Could not chmod directory$dir: $?\n";
    }

    # Copy the directory
    if ($^O =~ /Win32/)
    {
        print "\nRunning $home_dir\\..\\..\\bin\\cp 
            on $testdir\\test\\directory$dir.\n" if ($verbose);
        system("$home_dir\\..\\..\\bin\\cp -rv directory$dir copieddir
+ectory$dir");
    }
    else
    {
        system("/bin/cp -r directory$dir copieddirectory$dir");
          or warn "Could not copy directory$dir to copieddirectory$dir
+: $?\n";
    }

    # Rename the directory
    if (!-d "copieddirectory$dir")
    {
        print "copieddirectory$dir does not exist!\n" if $verbose;
    }
    if ($^O =~ /Win32/)
    {
        system("move copieddirectory$dir ..\\test1\\moveddirectory$dir
+ > out.txt");
        if (-e "out.txt")
        {
            unlink("out.txt") or die "Can't unlink out.txt: $!\n";
        }
    }
    else
    {
        system("/bin/mv copieddirectory$dir ../test1/moveddirectory$di
+r");
          or warn "Could not move directory$dir to test1: $?\n";
    }

    # Delete the copied directory
    if ($^O =~ /Win32/)
    {
        rmdir("..\\test1\\moveddirectory$dir");
    }
    else
    {
        system("/bin/rm -r ../test1/moveddirectory$dir");
          or warn "Could not remove test1\\directory$dir: $?\n";
    }

    # Remove the directory
    if ($^O =~ /Win32/)
    {
        rmdir("directory$dir") or die "Can't remove directory: $!\n";
    }
    else
    {
        system("/bin/rm -r directory$dir");
          or warn "Could not remove directory$dir: $?\n";
    }
}

print "complete!\n" if ($verbose);
# Change back to the top directory
chdir($home_dir) or die "Can't move back to $home_dir: $!\n";

sub usage
{
    print "
$0 [options]

Options:
    -num          The number of loops to run, default $num
    -testdir      Location to run the test within
    -verbose      Run with messaging
    \n";
    exit(0);
}
[download]

Looking more closely at this version of your code, I'm wondering...
• Why do you do mkdir( "directory$dir",0755 ); and then turn right around and chmod that new directory to 0777? Why not just tell mkdir to use the intended permissions in the first place? (As it turns out, 0777 is said to be the default setting for mkdir.)
• Even if you really had to do chmod on files or directories, why use a system call for that? Is there some problem with using the perl built-in chmod function? (I would expect it to work in an OS-independent manner.)
• Why do the if ($^O =~ /Win32/) branching so many times? I think the two points above would eliminate most of the OS-dependent branching, but if you really still have some points where you need to branch, group those things together a little more, to minimize the number of conditional blocks, and make the code easier to read/maintain.
• It looks like you may be lacking some OS-dependent branching that should be there (near the beginning, where your "die" messages always have backslash paths, regardless of OS).

If you were to use File::Spec (as suggested above), here's how the code would start out:

use strict;
use warnings;
use Cwd;
use Getopt::Long;
use File::Spec;   # this will automatically load OS-appropriate functi
+ons

# ... [snip] ...

# Get the current working directory
my $home_dir = getcwd;

# Change to the test directory
chdir($testdir) or die "$0: chdir $testdir: $!";

# Set up test dirs if they do not exist
for my $t ( qw/test test1/ ) {
    mkdir $t or die "mkdir ". File::Spec->catfile($testdir, $t) .": $!
+\n";
}

# Change to the test area
chdir("test") or die "chdir test: $!\n";

# Directory Manipulation
for my $dir ( 0 ..  $num-1 ) {
    my $dirname = "directory$dir";

    # Make the directory
    if (!-d $dirname ) {
        mkdir $dirname or 
            die "mkdir ". File::Spec->catfile( $testdir, "test", $dirn
+ame ) .": $!\n";
    }
    #...
[download]

I hope that gets the general idea across. It looks like your script is simply meant to check that certain operations work as hoped for, and doesn't really accomplish anything other than testing, so I won't pursue it further.

I'll just emphasize that you should use perl built-in functions and core modules (e.g. File::Copy whenever they are available, rather than system calls to shell commands -- perl already provides a lot of OS-independence for you, and you'll have fewer problems and less code to write that way.

If you really must use system calls to run OS-dependent tools, modularize and/or group those things so that they hang together for each OS. Your code tests the OS type in five different places, and you shouldn't have to do that test more than once (or not at all, with proper use of existing modules).

As I mentioned this is to test a filter driver, so I need to make the OS calls with system as they are checked differently than calls made within Perl; and really that is what I need to test. Things like the chmod example you mention are part of the test, to make sure the filter captures and does not barf on things like a chmod call on a directory. So, yes, it is testing and checking that certain operations work as hoped for.
I should do better with the OS dependency and group better, honestly though this script is much cleaner than the one I inherited, and its about 33% smaller than the original one as well. More cleanup on the OS stuff is on my list, I still have no idea why the System calls are suddenly acting up, but at least I can get by with them for now.
Thanks!