java.security.AccessControlException: access denied

I'm trying to get my permissions to work properly. I get the error below and pasted below that is the supporting code which includes the policy file and java file being tested. I know my path is correct and that I have enabled read and write so I'm not sure why its giving me the error? Thoughts? Is there something that I'm missing? As I said I'm positive the path is correct and I have a stable internet connection so I know dropbox is connected.

package Project1Package;

import Project1Package.MySecurityException;
import java.util.*;
import java.io.*;
import java.net.*;
import java.lang.reflect.*;

/**
 *  Class designed to illustrate security policy features
 */
public class SecurityTest
{
    
    /**
     * An empty constructor for the object
     */
    public SecurityTest()
    {
        
    }

/**
     * The JVM's entry-point into this class; used to run the class from the
     * command-line (terminal window)
     *
     * @param args String[]   the arguments passed into the program on the command-line
     *
     * @return void
     */
    public static void main(String args[])
    {
        SecurityTest oSecurityTest;
        String strHold, strPath;
        oSecurityTest = new SecurityTest();
        
        if(true)
        {
            System.getProperties().setProperty("java.security.policy", "d:\\Dropbox\\JavaEE\\Project1\\src\\generic\\mysecurity.policy");
            System.setSecurityManager(new SecurityManager());
            //-Djava.security.policy==file:/L:/MATC/Preps/152-113_prep/modules/module1/lectures/examples/mysecurity.policy        
        }

//security concerns should be a fundamental element of any software design; specifically, one should identify 
        //resources in shared domains, communications channels that are to be used, environment metadata, method 
        //inputs and outputs, exception handling design, and external module and/or system dependencies
        
        //a security policy can be file-based; a default system policy is installed by the JRE; when the JVM loads, the 
        //system policy is loaded first followed by any policy information contained in an optional user policy; additionally, 
        //a policy can be specified at JVM launch
        
        //default JRE policy:  java.home/lib/security/java.policy
        //user policy:  user.home/.java.policy
        //command-line policy use:  java -Djava.security.manager -Djava.security.policy==someURL SomeApp
        
        //a policy is enforced by a SecurityManager; in the first two examples, the SecurityManager would be invoked
        //in code; the third example, the SecurityManager is started at the launch of the JVM

try
        {
            strHold = "Hello";
            strHold += System.getProperty ("line.separator");
            strHold += "I saw the Transformers movies with my boys this summer";

strPath = "d:\\Dropbox\\JavaEE\\Project1\\data.txt";
            oSecurityTest.writeFile(strPath, strHold);  //invoke code that writes to a file

strHold = oSecurityTest.readFile (strPath);  //invoke code that reads from a file
            System.out.println(strHold.toLowerCase ());

oSecurityTest.manageProperty ("java.jvm");  //invoke code that manipulates the system Property instance

//    oSecurityTest.openPort (8080);  //invoke code that opens a network connection

oSecurityTest.manageReflection ();  //invokes code that utilizes reflection
        }
        catch(MySecurityException secEx)
        {
            //here, I have encountered a security exception; I would need to handle it since the exception
            //has been bubbled up to the top; depending on the severity of the problem, I may just want
            //my process to continue running; sometimes, I may need to escalate by retrying with default
            //data, calling/paging on on-call tech, or killing the process
            secEx.printStackTrace();
        }
        catch(Exception Ex)
        {
            Ex.printStackTrace();
        }
    }

/**
     *  Creates an instance and tries to access fields within the instance
     */
    public void manageReflection()
    {
        Object oVal;
        Class oClass;
        Field araFields[];
        int ilen;
        
        try
        {
            oVal = new Project1Package.GenericContainer();
            oClass = oVal.getClass ();  //get the class instance singleton for this type
            
             //return an array all of the fields (public, protected, private) defined in this class 
            araFields = oClass.getDeclaredFields (); 
            System.out.println (araFields);  
            //everything works fine because of the policy granting "suppressAccessChecks" 
            //permission;... now try this on a class loaded outside of this classloader
            
            
            oVal = new String();
            oClass = oVal.getClass ();  //get the class instance singleton for this type
            araFields = oClass.getDeclaredFields (); 
            System.out.println (araFields);
            //it works fine again... but only because of an additional policy grant: "accessDeclaredMembers"
        }
        catch(Exception Ex)
        {
            Ex.printStackTrace ();
        }
    }
    
    /**
     *  Reads and writes a property to system properties
     *
     *  @param String strIn
     */
    public void manageProperty(String strIn) throws MySecurityException
    {
        String strHold;
        Properties oProps;
        
        //BEGIN INPUT CHECKS
        if(strIn == null || strIn.length () == 0)
            throw new MySecurityException("No input supplied. You must supply a string value.", MySecurityException.INPUT_FAIL, "strIn", strIn);

strHold = System.getProperty (strIn);
        if(strHold == null)
        {
            oProps = System.getProperties ();  //get the system properties instance
            oProps.setProperty (strIn, "1.6");  //attempt to set a new value in the system properties instance
        }
        System.out.println (System.getProperty(strIn));
        //this works fine even with a SecurityManager installed because our policy file includes
        //a PropertyPermission wildcard of '*'... effectively granting our code the right to both
        //read and write properties in the system properties instance
    }
    
    /**
     *  Opens a port for reading
     *
     *  @param int iIn      the port 
     */
    public void openPort(int iIn) throws MySecurityException
    {
        String strHold;
        ServerSocket oSrvSocket;
        Socket oSocket;

//BEGIN INPUT CHECKS
        if(iIn < 1024 && iIn != 80)
            throw new MySecurityException("Ports must be >= 1024.", MySecurityException.INPUT_FAIL, "iIn", iIn);

try
        {
            //open a connection to yahoo.com on the port specified by iIn
           oSocket = new Socket("yahoo.com", iIn);  
           //with a SecurityManager installed, this is possible with a grant of SocketPermission
        }
        catch(UnknownHostException UEx)
        {
            UEx.printStackTrace();
        }
        catch(IOException IEx)
        {
            IEx.printStackTrace();
        }
    }

/**
     *  Reads data from a file
     *  
     *  @param String strInPath     the path to the file
     *  @return String     the file contents
     */
    public String  readFile(String strInPath) throws MySecurityException
    {
            RandomAccessFile oInFile;
            String strHold;
            StringBuffer strbHold = null;
            
            try
            {
               //BEGIN INPUT CHECKS
               if(strInPath == null || strInPath.length () == 0)
                    throw new MySecurityException("Path cannot be empty", MySecurityException.INPUT_FAIL, "strInPath", strInPath);
               else if(strInPath.length() > 512)
                    throw new MySecurityException("Path cannot exceed 512 characters", MySecurityException.INPUT_FAIL, "strInPath", strInPath);
               else if(strInPath.indexOf(' ') >= 0)
                    throw new MySecurityException("Path cannot contain spaces", MySecurityException.INPUT_FAIL, "strInPath", strInPath);

strbHold = new StringBuffer();
                oInFile = new RandomAccessFile(strInPath, "r");
                while(oInFile.getFilePointer() < oInFile.length())
                {
                    strHold = oInFile.readLine();
                    strbHold.append (strHold);
                    strbHold.append (System.getProperty ("line.separator"));
                }
                oInFile.close();

//when a SecurityManager is installed, one must explicitly grant permission using
                //FilePermission for a specific file or directory; you can grant the code rights to 
                //read, write, and/or execute
            }
            catch(IOException Ex)
            {
                Ex.printStackTrace ();
            }

//BEGIN OUTPUT CHECKS
           if(strbHold == null)
                throw new MySecurityException("File contents are invalid", MySecurityException.OUTPUT_FAIL, "strbHold", strbHold);
           else if(strbHold.length() > 1000000000)
                throw new MySecurityException("File should not exceed 1Gb in size", MySecurityException.OUTPUT_FAIL, "strbHold.length()", strbHold.length());

if(strbHold != null)
                return strbHold.toString ();
            else
                return null;
    }
    
    /**
     *  Writes data to a file
     *
     *  @param String strIn
     */
    public void writeFile(String strInPath, String strIn) throws MySecurityException
    {
        RandomAccessFile oOutFile;

try
        {
               //BEGIN INPUT CHECKS
               if(strInPath == null || strInPath.length () == 0)
                    throw new MySecurityException("Path cannot be empty", MySecurityException.INPUT_FAIL, "strInPath", strInPath);
               else if(strInPath.length() > 512)
                    throw new MySecurityException("Path cannot exceed 512 characters", MySecurityException.INPUT_FAIL, "strInPath", strInPath);
               else if(strInPath.indexOf(' ') >= 0)
                    throw new MySecurityException("Path cannot contain spaces", MySecurityException.INPUT_FAIL, "strInPath", strInPath);
               else if(strIn == null || strIn.length () == 0)
                    throw new MySecurityException("File contents cannot be empty", MySecurityException.INPUT_FAIL, "strIn", strIn);
               else if(strIn.length() > 1000000000)
                    throw new MySecurityException("File should not exceed 1Gb in size", MySecurityException.INPUT_FAIL, "strIn.length()", strIn.length());

oOutFile = new RandomAccessFile(strInPath, "rw");
            oOutFile.seek(oOutFile.length());
            oOutFile.writeBytes("Entry at " + new Date() + ":");
            oOutFile.writeBytes(System.getProperty("line.separator"));
            oOutFile.writeBytes(strIn);
            oOutFile.writeBytes(System.getProperty("line.separator"));
            oOutFile.close();
        }
        catch(IOException Ex)
        {
            Ex.printStackTrace();
        }
    }
}

I skipped over all that code, but it looks like you have an extra " character in line 4 of your policy file.

Your right, I took care of the extra " mark but it still gives the same error. Didn't see that though thanks.